From 3572f0e6324e35a8143026e20355ae08ae0dd1e6 Mon Sep 17 00:00:00 2001 From: johnman Date: Mon, 14 Oct 2024 20:05:06 +0000 Subject: [PATCH] =?UTF-8?q?Deploying=20to=20gh-pages=20from=20@=20built-on?= =?UTF-8?q?-openfin/container-starter@37cf2ee0e48d27f218c49990ed2a84de989f?= =?UTF-8?q?f9e5=20=F0=9F=9A=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../use-logging-apis/html/app.html | 41 +- .../use-logging-apis/html/provider.html | 73 + .../use-logging-apis/js/app.bundle.js | 133 +- .../use-logging-apis/js/provider.bundle.js | 22885 ++++++++++++++++ .../use-logging-apis/manifest.fin.json | 47 +- .../uploads/applogs/AppLogs.md | 4 + .../uploads/opfslogs/OPFSLogs.md | 3 + .../uploads/runtimelogs/SystemLogs.md | 3 + 8 files changed, 23075 insertions(+), 114 deletions(-) create mode 100644 dev/john/update-logging-example/use-logging-apis/html/provider.html create mode 100644 dev/john/update-logging-example/use-logging-apis/js/provider.bundle.js create mode 100644 dev/john/update-logging-example/use-logging-apis/uploads/applogs/AppLogs.md create mode 100644 dev/john/update-logging-example/use-logging-apis/uploads/opfslogs/OPFSLogs.md create mode 100644 dev/john/update-logging-example/use-logging-apis/uploads/runtimelogs/SystemLogs.md diff --git a/dev/john/update-logging-example/use-logging-apis/html/app.html b/dev/john/update-logging-example/use-logging-apis/html/app.html index ff7839df..1269f5a1 100644 --- a/dev/john/update-logging-example/use-logging-apis/html/app.html +++ b/dev/john/update-logging-example/use-logging-apis/html/app.html @@ -2,7 +2,7 @@ - How to collect debug logs + Client that generates logs @@ -12,8 +12,8 @@
-

How to collect logs.

-

Demonstrate how to use logging APIs

+

A client that generates logs

+

Log via Channel API vs console log

OpenFin @@ -22,41 +22,18 @@

Demonstrate how to use logging APIs

-
-
-

Select a debug log.

-
- -
- -
-
-

Upload your applications log.

- +

Console Log A Message

+ +

Channel API Log A Message

+

Preview


+				
 			

 		

-		
+		

 	
 
diff --git a/dev/john/update-logging-example/use-logging-apis/html/provider.html b/dev/john/update-logging-example/use-logging-apis/html/provider.html
new file mode 100644
index 00000000..c351559c
--- /dev/null
+++ b/dev/john/update-logging-example/use-logging-apis/html/provider.html
@@ -0,0 +1,73 @@
+
+
+	
+		
+		How to collect debug logs
+		
+		
+		
+		
+	
+
+	
+		

+			

+				
How to collect logs.

+				
Demonstrate how to use logging related APIs

+			

+			

+				OpenFin
+			

+		

+		

+			

+				

+					

+						

+							
Select a debug log.

+							

+								
+							

+							
+						

+					

+					
Upload your applications log (console messages).

+					
+					
Upload your OPFS log (Channel API Messages).

+					
+					
Console Log A Message

+					
+					
Channel API Log A Message

+					
+				

+			

+			

+				
Preview

+				

+				
+			

+		

+		
+	
+
diff --git a/dev/john/update-logging-example/use-logging-apis/js/app.bundle.js b/dev/john/update-logging-example/use-logging-apis/js/app.bundle.js
index 19bf6c9a..3733c795 100644
--- a/dev/john/update-logging-example/use-logging-apis/js/app.bundle.js
+++ b/dev/john/update-logging-example/use-logging-apis/js/app.bundle.js
@@ -22537,101 +22537,78 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _openfin_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @openfin/core */ "../../node_modules/@openfin/core/out/mock.js");
 
-let fileName;
-let debugLogStr;
-let debugLogFile;
-document.addEventListener("DOMContentLoaded", async () => {
-    try {
-        await initDom();
-    }
-    catch (error) {
-        console.error(error);
-    }
+const channelName = `${_openfin_core__WEBPACK_IMPORTED_MODULE_0__.fin.me.identity.uuid}-logger`;
+let channelClient;
+window.addEventListener("DOMContentLoaded", async () => {
+    const consoleLogBtn = document.querySelector("#console-app-log");
+    if (consoleLogBtn) {
+        consoleLogBtn.addEventListener("click", consoleLogMessage);
+    }
+    const channelLogBtn = document.querySelector("#channel-app-log");
+    if (channelLogBtn) {
+        channelLogBtn.addEventListener("click", channelLogMessage);
+    }
+    const clearPreviewBtn = document.querySelector("#clear-preview");
+    if (clearPreviewBtn) {
+        clearPreviewBtn.addEventListener("click", clearPreview);
+    }
+    await setupChannelClient();
 });
 /**
- * Populates DOM with the UI elements and adds listeners obtaining selected/submitted options.
+ * Sends a message to console log.
  */
-async function initDom() {
-    const logListElement = document.querySelector("#log-list");
-    if (logListElement) {
-        await createLogDropDown(logListElement);
-        logListElement.addEventListener("change", async (selectionChangeEvent) => {
-            fileName = selectionChangeEvent.target.value;
-        });
-    }
-    const upload = document.querySelector("#upload-form");
-    if (upload) {
-        upload.addEventListener("submit", uploadHandler);
+async function consoleLogMessage() {
+    const logPreview = document.querySelector("#preview");
+    try {
+        const message = `Sending view console log message: ${Date.now()}`;
+        console.log(message);
+        if (logPreview) {
+            logPreview.textContent += `
+Console Logged the following message: 
+"${message}"`;
+        }
     }
-    const sendAppLogBtn = document.querySelector("#send-app-log");
-    if (sendAppLogBtn) {
-        sendAppLogBtn.addEventListener("click", sendApplicationLogs);
+    catch (err) {
+        if (logPreview) {
+            logPreview.textContent += `Error console logging message: ${err.message}`;
+        }
     }
 }
 /**
- * Handle uploads.
- * 1. Creates a FormData object.
- * 2. Creates a File object from the string of the Runtime debug log file contents.
- * 3. Populates the FormData object with necessary parameters to be read by the server.
- * 4. Uploads the created runtime debug log file to a server endpoint.
- * @param submitEvent The event to handle.
+ * Sends a message to console log through the Channel API.
  */
-async function uploadHandler(submitEvent) {
-    submitEvent.preventDefault();
-    if (!fileName) {
-        fileName = "debug.log";
-    }
-    const formData = new FormData();
-    debugLogStr = await getLogFromName(fileName);
-    debugLogFile = new File([debugLogStr], fileName, { type: "text/plain" });
-    formData.append("file", debugLogFile);
-    formData.append("filename", fileName);
-    formData.append("uuid", _openfin_core__WEBPACK_IMPORTED_MODULE_0__.fin.me.uuid);
-    const uploadState = await fetch("https://built-on-openfin.github.io/container-starter/dev/john/update-logging-example/use-logging-apis/uploads", {
-        method: "POST",
-        body: formData
-    });
-    const uploadStateJson = await uploadState.json();
-    const uploadStateJsonString = JSON.stringify(uploadStateJson, null, 5);
-    const logs = `${new Date().toLocaleTimeString()}: ${uploadStateJsonString}\n`;
+async function channelLogMessage() {
     const logPreview = document.querySelector("#preview");
-    if (logPreview) {
-        logPreview.textContent += logs;
-    }
-}
-/**
- * Sends a message to the OpenFin RVM to send the application logs.
- */
-async function sendApplicationLogs() {
     try {
-        const appLogResponse = await _openfin_core__WEBPACK_IMPORTED_MODULE_0__.fin.Application.getCurrentSync().sendApplicationLog();
-        console.log(`Log ID: ${appLogResponse.logId}`);
+        const message = `Sending view channel log message: ${Date.now()}`;
+        if (logPreview) {
+            logPreview.textContent += `
+Sending the following message through the Channel API: 
+"${message}"`;
+        }
+        await channelClient.dispatch("log", message);
     }
-    catch {
-        // swallow unnecessary errors.
+    catch (err) {
+        if (logPreview) {
+            logPreview.textContent += `Error sending message through Channel API: ${err.message}`;
+        }
     }
 }
 /**
- * Retrieves the runtime debug log from a filename.
- * @param name file name of the runtime debug log to retrieve.
- * @returns the log content.
+ * Sets up the Channel Client.
  */
-async function getLogFromName(name) {
-    const log = await _openfin_core__WEBPACK_IMPORTED_MODULE_0__.fin.System.getLog({ name });
-    return log;
+async function setupChannelClient() {
+    if (channelClient === undefined) {
+        channelClient = await _openfin_core__WEBPACK_IMPORTED_MODULE_0__.fin.InterApplicationBus.Channel.connect(channelName);
+    }
 }
 /**
- * Creates an HTMLOptionElement for each of the Runtime debug logs.
- * @param parentElement HTML Element to append the log filename HTMLOptionElement to.
+ * Clears the preview log.
  */
-async function createLogDropDown(parentElement) {
-    const logList = await _openfin_core__WEBPACK_IMPORTED_MODULE_0__.fin.System.getLogList();
-    for (const log of logList) {
-        const logElement = document.createElement("option");
-        logElement.id = log.date;
-        logElement.textContent = log.name;
-        logElement.value = log.name;
-        parentElement.append(logElement);
+function clearPreview() {
+    const logPreview = document.querySelector("#preview");
+    if (logPreview) {
+        logPreview.textContent = "";
     }
 }
 
@@ -22639,4 +22616,4 @@ async function createLogDropDown(parentElement) {
 
 /******/ })()
 ;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"app.bundle.js","mappings":";;;;;;;;;;AAAa;;AAEb,8CAA6C,EAAE,aAAa,EAAC;;AAE7D,iBAAiB,mBAAO,CAAC,mDAAQ;AACjC,mBAAmB,mBAAO,CAAC,gEAAkB;AAC7C,iBAAiB,mBAAO,CAAC,4DAAgB;;AAEzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB;AACxB,KAAK;AACL;AACA,GAAG;AACH,EAAE;AACF;AACA;;AAEA,sHAAsH,qBAAM,mBAAmB,qBAAM;;AAErJ;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;AACA,mDAAmD,0BAA0B;AAC7E,2BAA2B,sBAAsB,qBAAqB,mBAAmB;AACzF;AACA;AACA;AACA;AACA,2DAA2D,cAAc;AACzE;AACA;AACA,UAAU,8BAA8B,KAAK,0BAA0B,oBAAoB,4BAA4B;AACvH,IAAI,0BAA0B,gFAAgF,oCAAoC;AAClJ;AACA,IAAI,0DAA0D,2CAA2C;AACzG,OAAO,oCAAoC,iBAAiB,mCAAmC;AAC/F,IAAI;AACJ;AACA;AACA,6BAA6B,wBAAwB;AACrD;AACA;AACA;AACA,qDAAqD,aAAa;;AAElE;;AAEA;AACA;AACA;AACA;AACA;AACA,8CAA8C,aAAa;;AAE3D;;AAEA;AACA,uDAAuD,kCAAkC;AACzF;AACA;AACA;AACA,2DAA2D,cAAc;AACzE;AACA,yEAAyE,oDAAoD;AAC7H;AACA;AACA;AACA,6DAA6D,aAAa;;AAE1E;;AAEA,+CAA+C,aAAa;;AAE5D;;AAEA;AACA;AACA,oDAAoD,gCAAgC;AACpF;AACA;AACA;AACA,2DAA2D,cAAc;AACzE;AACA,kEAAkE,mDAAmD;AACrH;AACA;AACA;AACA,sDAAsD,aAAa;;AAEnE;;AAEA;AACA;AACA,+CAA+C,uBAAuB;AACtE;AACA;AACA;AACA,2DAA2D,cAAc;AACzE;AACA,qDAAqD,2BAA2B;AAChF,iCAAiC,oDAAoD;AACrF;AACA,IAAI,8BAA8B;AAClC;AACA;AACA;AACA,kDAAkD,aAAa;;AAE/D;;AAEA;AACA,yDAAyD,oBAAoB;AAC7E,uBAAuB,0BAA0B,GAAG,qBAAqB,OAAO,oBAAoB;AACpG;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2DAA2D,cAAc;AACzE;AACA;AACA,UAAU,uCAAuC,GAAG,6BAA6B,OAAO,0BAA0B;AAClH,IAAI,gCAAgC,GAAG,2BAA2B,OAAO,0BAA0B;AACnG,uBAAuB,0BAA0B;AACjD;AACA;AACA;AACA,gDAAgD,aAAa;;AAE7D;;AAEA;AACA,kDAAkD,mBAAmB;AACrE;AACA;AACA;AACA,2DAA2D,cAAc;AACzE;AACA;AACA,UAAU,qBAAqB,GAAG,mBAAmB,kBAAkB,gCAAgC;AACvG,oDAAoD,sBAAsB;AAC1E;AACA,0CAA0C,kCAAkC,GAAG,4CAA4C;AAC3H,QAAQ,mCAAmC;AAC3C;AACA;AACA;AACA,8CAA8C,aAAa;;AAE3D;;AAEA;AACA,0EAA0E,qBAAqB;AAC/F,IAAI,mBAAmB;AACvB;AACA;AACA,kGAAkG,0BAA0B;AAC5H;AACA;AACA;AACA,mDAAmD,aAAa;;AAEhE;;AAEA;AACA,kDAAkD,qBAAqB;AACvE;AACA;AACA;AACA,2DAA2D,cAAc;AACzE;AACA;AACA,UAAU,qBAAqB,GAAG,mBAAmB,kBAAkB,gCAAgC;AACvG,yCAAyC,yBAAyB;AAClE,IAAI;AACJ;AACA,IAAI,qEAAqE;AACzE,IAAI,8BAA8B,6BAA6B,6CAA6C;AAC5G,IAAI,mCAAmC;AACvC;AACA,6BAA6B,yBAAyB,qCAAqC;AAC3F;AACA;AACA;AACA;AACA,gDAAgD,aAAa;;AAE7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,0BAA0B,GAAG;AACnC,MAAM,kCAAkC,GAAG;AAC3C,MAAM,oBAAoB,GAAG;AAC7B,MAAM,2BAA2B,GAAG;AACpC,MAAM,uBAAuB,GAAG;AAChC,MAAM,qBAAqB,GAAG;AAC9B,MAAM,mBAAmB,GAAG;AAC5B,MAAM,qBAAqB,GAAG;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU,2BAA2B;AACrC,MAAM,+BAA+B,uCAAuC,2BAA2B;AACvG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,oCAAoC;AACnD;AACA;AACA,CAAC;AACD;AACA;AACA,CAAC;AACD;AACA,0CAA0C,4BAA4B;AACtE,CAAC;AACD;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C,aAAa;AAC3D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,iDAAiD,aAAa;AAC9D,kFAAkF,wBAAwB;AAC1G,+DAA+D,kBAAkB;AACjF,8CAA8C,yBAAyB;AACvE,sDAAsD,yBAAyB,KAAK,uBAAuB;AAC3G;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,oCAAoC;AACpD;AACA;AACA,EAAE;AACF;AACA;AACA,EAAE;AACF;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA,EAAE;;AAEF;;AAEA;AACA;AACA;AACA,CAAC;;AAED;;AAEA;;AAEA;;AAEA;;AAEA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4CAA4C,aAAa;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,oBAAoB,IAAI,qBAAqB;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mEAAmE;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qEAAqE;AACrE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,sBAAsB;AAC5E;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,sBAAsB;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,sDAAsD,sBAAsB;AAC5E;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,sBAAsB;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B;AAC/B;AACA;AACA;AACA;AACA,4BAA4B,cAAc;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,uDAAuD,aAAa;AACpE;AACA;AACA;AACA,yDAAyD,WAAW;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,gCAAgC;AAChD;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD;AACrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,kBAAkB;AACzC;AACA,kCAAkC,oBAAoB;AACtD;AACA;AACA;AACA;AACA;AACA,gBAAgB,gBAAgB;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA,qEAAqE,YAAY;AACjF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B;AAC5B,cAAc;AACd;AACA;AACA,yDAAyD,kBAAkB;AAC3E;AACA,gCAAgC,0BAA0B;AAC1D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,4CAA4C;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yCAAyC,wCAAwC;AACjF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,iBAAiB,aAAa;AAC9B,4BAA4B,YAAY;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,iBAAiB,aAAa;AAC9B,gCAAgC,YAAY;AAC5C;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA,4CAA4C,aAAa;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA,mDAAmD,aAAa;AAChE;AACA;AACA,mCAAmC,gBAAgB;AACnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,KAAK;AAClB;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gEAAgE,iBAAiB;AACjF,4DAA4D;AAC5D;AACA;AACA;AACA;AACA,qCAAqC,0BAA0B;AAC/D;AACA;;AAEA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+EAA+E,cAAc;AAC7F;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA,wDAAwD,aAAa;AACrE;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,KAAK;AACzB,oBAAoB,QAAQ,0CAA0C,GAAG;AACzE;AACA;AACA;AACA,oBAAoB,SAAS;AAC7B,mDAAmD,MAAM;AACzD;AACA;AACA;AACA;AACA;;AAEA;;AAEA,uDAAuD,aAAa;AACpE;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,qBAAqB;AACzC,oBAAoB,KAAK;AACzB,8BAA8B,GAAG,GAAG,uBAAuB;AAC3D,yEAAyE,MAAM;AAC/E;AACA,aAAa;AACb,qBAAqB;AACrB;AACA,mCAAmC,IAAI;AACvC,uCAAuC,GAAG;AAC1C,yEAAyE,OAAO;AAChF;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,gBAAgB,oCAAoC;AACpD;AACA;AACA,EAAE;AACF;AACA;AACA,EAAE;AACF;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA,EAAE;;AAEF;AACA;AACA;AACA;AACA;AACA,gBAAgB,oCAAoC;AACpD;AACA;AACA,EAAE;AACF;AACA;AACA,EAAE;AACF;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA,EAAE;;AAEF;AACA;AACA;AACA;AACA;AACA,gBAAgB,oCAAoC;AACpD;AACA;AACA,EAAE;AACF;AACA;AACA,EAAE;AACF;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA,EAAE;;AAEF;;AAEA,uDAAuD,aAAa;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,QAAQ,MAAM,yBAAyB;AAC7E;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA,8CAA8C,QAAQ;AACtD;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,aAAa;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,gCAAgC;AAC9D,qBAAqB,gBAAgB,KAAK,mBAAmB;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gDAAgD,OAAO;AACvD;AACA;AACA;AACA;AACA;AACA,0DAA0D,aAAa;AACvE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C,OAAO;AACpD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,+CAA+C;AAChE,iBAAiB,iEAAiE;AAClF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA,+EAA+E,mBAAmB;AAClG;AACA,wEAAwE,mBAAmB;AAC3F,kEAAkE,iBAAiB;AACnF;AACA;AACA;AACA;AACA;AACA;AACA,0CAA0C,yBAAyB;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yCAAyC,oBAAoB,2BAA2B,mBAAmB;AAC3G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC,4BAA4B;AAChE;AACA;AACA;AACA,+BAA+B,4BAA4B;AAC3D;AACA;AACA;AACA,wFAAwF,UAAU;AAClG,8BAA8B,kBAAkB;AAChD;AACA;AACA,YAAY,iBAAiB;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wEAAwE,2BAA2B;AACnG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B;AAC1B;AACA;AACA;AACA,4FAA4F,gBAAgB,KAAK,kBAAkB;AACnI;AACA;AACA;AACA,4DAA4D,eAAe;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,gBAAgB;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yCAAyC,cAAc;AACvD;AACA;AACA;AACA;AACA;AACA,2CAA2C,eAAe;AAC1D;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC,iCAAiC;AACxE;AACA,2BAA2B,gBAAgB;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4DAA4D,gDAAgD;AAC5G,mEAAmE,oBAAoB;AACvF,wBAAwB,gBAAgB;AACxC,2DAA2D,8CAA8C,IAAI,UAAU;AACvH,kEAAkE,mBAAmB;AACrF;AACA;AACA;AACA,gDAAgD,UAAU;AAC1D;AACA,qCAAqC,eAAe;AACpD;AACA;AACA;AACA;AACA;AACA,2BAA2B,gBAAgB;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4DAA4D,gDAAgD;AAC5G;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC,gBAAgB;AACxD;AACA;AACA,2BAA2B,gBAAgB;AAC3C;AACA;AACA;AACA;AACA,kDAAkD,iCAAiC;AACnF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C,qBAAqB;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,wDAAwD,aAAa;AACrE;AACA;AACA;AACA;;AAEA;;AAEA,4CAA4C,aAAa;AACzD;AACA;AACA;AACA;AACA,4CAA4C,4CAA4C;AACxF,0CAA0C,4CAA4C;AACtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,sDAAsD,2BAA2B,UAAU,SAAS;AACpG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C,gCAAgC;AAC7E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA;AACA,0DAA0D,wBAAwB;AAClF,qBAAqB,SAAS;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,6EAA6E,SAAS;AACtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,wDAAwD,yBAAyB;AACjF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB;AACxB,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,yDAAyD,uBAAuB;AAChF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C,uCAAuC;AACrF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+CAA+C,kCAAkC;AACjF;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,8DAA8D,kBAAkB;AAChF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,gEAAgE,kBAAkB;AAClF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C,uCAAuC;AACrF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+CAA+C,kCAAkC;AACjF;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,gEAAgE,kBAAkB;AAClF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oDAAoD;AACpD;AACA;AACA;AACA;AACA;AACA,oBAAoB,kDAAkD;AACtE;AACA,QAAQ;AACR;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA,sBAAsB;AACtB,+CAA+C,2BAA2B;AAC1E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA;AACA,0CAA0C,uCAAuC;AACjF,qBAAqB,SAAS;AAC9B;AACA;AACA,eAAe,kCAAkC;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ,QAAQ;AACR;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ,QAAQ;AACR;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,2DAA2D,0BAA0B;AACrF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB,YAAY;AACZ;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB,YAAY;AACZ;AACA;AACA,YAAY;AACZ;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,sDAAsD,kBAAkB,UAAU,SAAS;AAC3F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA,kBAAkB,mBAAmB,IAAI,wBAAwB;AACjE,qDAAqD,oCAAoC;AACzF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,gBAAgB,WAAW,SAAS;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB;AACxB,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,iFAAiF,SAAS;AAC1F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB;AACxB,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,8DAA8D,kBAAkB;AAChF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB;AACxB,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,oEAAoE,4BAA4B;AAChG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB;AACxB,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,+DAA+D,kBAAkB;AACjF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA,eAAe,aAAa;AAC5B,eAAe,MAAM;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,gCAAgC,gBAAgB;AAChD;AACA,SAAS;AACT;AACA,2CAA2C,WAAW;AACtD;AACA,mEAAmE,yCAAyC;AAC5G;AACA;AACA;AACA,2FAA2F,MAAM;AACjG;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,4BAA4B;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,SAAS;AACT,gBAAgB,QAAQ,oCAAoC;AAC5D;AACA;AACA;AACA;AACA;AACA,oBAAoB,2BAA2B;AAC/C;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,UAAU;AAC1B;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mDAAmD,aAAa;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,8CAA8C;AACpF;AACA;AACA,sDAAsD,sCAAsC;AAC5F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yDAAyD,0BAA0B;AACnF;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C,oCAAoC;AACjF;AACA;AACA;AACA;AACA;AACA,0DAA0D,kBAAkB;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uDAAuD,kBAAkB;AACzE;AACA;AACA;AACA;AACA;AACA;AACA,cAAc,iBAAiB;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kDAAkD;AAClD,0DAA0D,mCAAmC;AAC7F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iEAAiE,kBAAkB;AACnF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uDAAuD,kBAAkB;AACzE;AACA;AACA;AACA;AACA;AACA,cAAc,iBAAiB;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,0BAA0B;AACvF;AACA;AACA;AACA;AACA;AACA,cAAc,iBAAiB;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA,yEAAyE,kBAAkB;AAC3F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uEAAuE,kBAAkB;AACzF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8DAA8D,kBAAkB;AAChF;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2CAA2C,oDAAoD;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+DAA+D,kBAAkB,UAAU,SAAS;AACpG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qCAAqC;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,2BAA2B;AAC7F;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C,oCAAoC;AACjF;AACA;AACA,gDAAgD;AAChD;AACA;AACA;AACA;AACA,qBAAqB,WAAW,SAAS,kDAAkD,kBAAkB;AAC7G;AACA;AACA;AACA,mCAAmC,wBAAwB;AAC3D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0CAA0C,cAAc;AACxD;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,wDAAwD;AACrH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mFAAmF,kBAAkB;AACrG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yCAAyC,oCAAoC;AAC7E;AACA;AACA;AACA;AACA;AACA,mBAAmB,mBAAmB,IAAI,wBAAwB;AAClE;AACA;AACA,6BAA6B,kBAAkB;AAC/C;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,oCAAoC;AACrD;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA;AACA,iDAAiD,aAAa;AAC9D;AACA;AACA;AACA,QAAQ,kBAAkB;AAC1B,QAAQ,YAAY;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;;AAEA;;AAEA;AACA;AACA;AACA,mDAAmD,aAAa;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,mDAAmD;AAChH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8EAA8E,QAAQ;AACtF;AACA;AACA;AACA,sFAAsF,SAAS;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oEAAoE,IAAI,8BAA8B,GAAG,8BAA8B;AACvI,oDAAoD,aAAa;AACjE;AACA,oEAAoE,IAAI,8BAA8B;AACtG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iEAAiE,yBAAyB;AAC1F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+DAA+D,yBAAyB;AACxF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iFAAiF,SAAS;AAC1F;AACA;AACA,qCAAqC,yCAAyC;AAC9E,cAAc;AACd;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wFAAwF,SAAS;AACjG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sFAAsF,SAAS;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD,iBAAiB;AACtE;AACA;AACA;AACA;AACA;AACA;AACA,6EAA6E,SAAS;AACtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,UAAU;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0FAA0F,SAAS;AACnG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wDAAwD,qCAAqC;AAC7F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C,yBAAyB,oCAAoC,wBAAwB;AACnI;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,mBAAmB;AACnB;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,UAAU;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yCAAyC,QAAQ;AACjD,6CAA6C,SAAS;AACtD;AACA;AACA;AACA,qBAAqB;AACrB,sBAAsB,mBAAmB;AACzC;AACA;AACA,0CAA0C,QAAQ;AAClD;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA,4IAA4I,aAAa;AACzJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA,uDAAuD,8CAA8C;AACrG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,wDAAwD,gCAAgC;AACxF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA,iEAAiE,qCAAqC;AACtG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qEAAqE,yBAAyB;AAC9F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8DAA8D,kCAAkC;AAChG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD,iBAAiB;AACtE;AACA;AACA;AACA;AACA;AACA;AACA,kFAAkF,SAAS;AAC3F;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAiD,iBAAiB;AAClE;AACA;AACA;AACA;AACA;AACA,6EAA6E,SAAS;AACtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wEAAwE,SAAS;AACjF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,WAAW,SAAS;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,kCAAkC;AAClC,oEAAoE,qCAAqC;AACzG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,WAAW,SAAS;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,WAAW,mBAAmB;AAC9B;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,eAAe;AACf;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC,UAAU;AAClD;AACA;AACA,gBAAgB;AAChB;AACA;AACA,aAAa;AACb;AACA,SAAS;AACT;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,kCAAkC;AAClC,iBAAiB,UAAU,4DAA4D,4BAA4B;AACnH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,kCAAkC;AAClC,oEAAoE,mBAAmB;AACvF;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA,qEAAqE,mBAAmB;AACxF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B,iBAAiB;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+CAA+C,iBAAiB;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,uBAAuB;AACnD;AACA;AACA,4DAA4D,6DAA6D;AACzH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,yDAAyD,uBAAuB;AAChF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,2DAA2D,oBAAoB;AAC/E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mDAAmD,QAAQ;AAC3D,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,4BAA4B,yBAAyB;AACrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mDAAmD,QAAQ;AAC3D,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,gCAAgC,yBAAyB;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,+BAA+B;AAC/B;AACA;AACA;AACA,yBAAyB,qFAAqF;AAC9G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,uDAAuD,aAAa;AACpE,sBAAsB,SAAS;AAC/B;AACA,gCAAgC,MAAM;AACtC,UAAU;AACV;AACA,6CAA6C;AAC7C;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,oCAAoC;AACrD;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA;AACA,iDAAiD,aAAa;AAC9D;AACA;AACA;AACA,QAAQ,yBAAyB;AACjC,QAAQ,mBAAmB;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;;AAEA;;AAEA,+DAA+D,aAAa;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,mDAAmD,aAAa;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0DAA0D;AAC1D;AACA,sCAAsC,kDAAkD;AACxF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2EAA2E,+BAA+B;AAC1G;AACA;AACA,iBAAiB,UAAU;AAC3B;AACA,iBAAiB,UAAU;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8EAA8E,SAAS;AACvF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,SAAS;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uDAAuD,yBAAyB;AAChF;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oFAAoF,SAAS;AAC7F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,UAAU;AAC3B;AACA;AACA;AACA,yBAAyB,0CAA0C;AACnE;AACA;AACA,+CAA+C;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,yCAAyC;AAClE;AACA;AACA,+CAA+C;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+EAA+E,SAAS;AACxF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kFAAkF,SAAS;AAC3F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gFAAgF,SAAS;AACzF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gDAAgD,WAAW;AAC3D;AACA;AACA;AACA,iBAAiB;AACjB;AACA,cAAc;AACd;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0CAA0C,WAAW;AACrD;AACA,iBAAiB;AACjB;AACA;AACA;AACA,yCAAyC,iCAAiC;AAC1E;AACA;AACA;AACA,cAAc;AACd;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iFAAiF,SAAS;AAC1F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,gDAAgD,iDAAiD;AACjG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,yBAAyB;AAC/E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,cAAc;AACpD;AACA;AACA;AACA;AACA;AACA,gEAAgE,2BAA2B;AAC3F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,mBAAmB;AACjD;AACA,4CAA4C,+BAA+B;AAC3E;AACA,aAAa;AACb,SAAS;AACT;AACA;AACA;AACA;AACA,kDAAkD,sCAAsC;AACxF;AACA;AACA;AACA;AACA;AACA;AACA,qCAAqC,yBAAyB,8DAA8D,gBAAgB;AAC5I;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb,cAAc,mBAAmB;AACjC;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA,+BAA+B,UAAU;AACzC;AACA;AACA,cAAc;AACd;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB,kBAAkB,mBAAmB;AACrC;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA,0BAA0B;AAC1B;AACA;AACA;AACA,mCAAmC,0BAA0B;AAC7D;AACA;AACA,kBAAkB;AAClB;AACA;AACA,aAAa;AACb,SAAS;AACT;AACA;AACA;AACA,iBAAiB,UAAU,kDAAkD,2BAA2B;AACxG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2DAA2D,kBAAkB;AAC7E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,+DAA+D,wBAAwB;AACvF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD;AACrD;AACA;AACA;AACA;AACA;AACA,oBAAoB,kDAAkD;AACtE;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,kBAAkB;AACtC;AACA;AACA,oBAAoB,uBAAuB;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,iBAAiB;AAC9C;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8DAA8D,2BAA2B;AACzF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA,qEAAqE,eAAe;AACpF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA,iDAAiD,8BAA8B;AAC/E;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA,wCAAwC,8BAA8B;AACtE;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,yDAAyD,wCAAwC;AACjG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,iBAAiB,aAAa;AAC9B,4BAA4B,YAAY;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,iBAAiB,aAAa;AAC9B,gCAAgC,YAAY;AAC5C;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,oCAAoC;AACrD;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA;AACA,iDAAiD,aAAa;AAC9D;AACA;AACA;AACA,QAAQ,qBAAqB;AAC7B,QAAQ,eAAe;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;;AAEA;AACA;AACA;AACA,MAAM,cAAc;AACpB;AACA;AACA;AACA,8CAA8C,aAAa;AAC3D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oEAAoE,yCAAyC;AAC7G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,SAAS;AAClC;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,aAAa;AACb,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2DAA2D,SAAS;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,WAAW,SAAS,iDAAiD,aAAa;AAClG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+DAA+D,SAAS;AACxE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oEAAoE,SAAS;AAC7E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0EAA0E,SAAS;AACnF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,WAAW,QAAQ,gCAAgC;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,sBAAsB;AAC5D;AACA;AACA;AACA;AACA,0BAA0B;AAC1B,gBAAgB,WAAW,QAAQ,gCAAgC;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,SAAS;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA,yDAAyD,YAAY,UAAU,SAAS;AACxF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,qBAAqB,SAAS;AAC9B;AACA;AACA;AACA;AACA,YAAY,iEAAiE;AAC7E;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,SAAS;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mEAAmE,SAAS;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,gBAAgB,WAAW,QAAQ,oBAAoB,mDAAmD,aAAa;AACvH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sEAAsE,SAAS;AAC/E;AACA;AACA;AACA,gBAAgB,WAAW,QAAQ,oBAAoB;AACvD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iEAAiE,SAAS;AAC1E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8DAA8D,SAAS;AACvE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iEAAiE,SAAS;AAC1E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yDAAyD,SAAS;AAClE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gEAAgE,SAAS;AACzE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,SAAS;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR,QAAQ;AACR,QAAQ;AACR,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gEAAgE,SAAS;AACzE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,WAAW,SAAS;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,SAAS;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gEAAgE,SAAS;AACzE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4DAA4D,SAAS;AACrE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8DAA8D,SAAS;AACvE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2DAA2D,SAAS;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA,gBAAgB;AAChB;AACA,gBAAgB;AAChB;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,gBAAgB;AACtE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+DAA+D,KAAK;AACpE;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,4EAA4E;AACpF;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0CAA0C,yBAAyB;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,4EAA4E;AACpF;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mEAAmE,cAAc;AACjF;AACA;AACA;AACA;AACA;AACA,QAAQ,4EAA4E;AACpF;AACA;AACA;AACA;AACA;AACA,sCAAsC;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mEAAmE,cAAc,UAAU,SAAS;AACpG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,MAAM;AACxE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR,8DAA8D,mDAAmD;AACjH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC,sDAAsD;AAC7F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,iBAAiB;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yCAAyC,kBAAkB;AAC3D,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,yDAAyD,WAAW;AACpE,mDAAmD,WAAW;AAC9D,yDAAyD,WAAW;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,qBAAqB;AACzC,2DAA2D,eAAe;AAC1E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0DAA0D,YAAY;AACtE;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B,mEAAmE;AAC7F;AACA;AACA;AACA;AACA,QAAQ;AACR,2DAA2D,YAAY;AACvE;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+DAA+D,WAAW;AAC1E,yDAAyD,WAAW;AACpE,+DAA+D,WAAW;AAC1E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,qBAAqB;AAC7C,+DAA+D,eAAe;AAC9E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,YAAY;AACzE;AACA;AACA;AACA,aAAa;AACb,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,8BAA8B;AAC3C,aAAa;AACb;AACA;AACA;AACA,6BAA6B,oBAAoB;AACjD,mCAAmC,IAAI;AACvC,uCAAuC,QAAQ;AAC/C;AACA,yCAAyC,MAAM;AAC/C;AACA,YAAY;AACZ,QAAQ;AACR;AACA;AACA;AACA,kEAAkE,SAAS,UAAU,SAAS;AAC9F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6EAA6E,SAAS;AACtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC,gBAAgB;AACnD;AACA;AACA;AACA,2EAA2E,SAAS;AACpF;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,iBAAiB;AAC/C;AACA;AACA;AACA;AACA,oDAAoD,KAAK;AACzD,uEAAuE,SAAS;AAChF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2DAA2D,OAAO;AAClE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,qBAAqB,SAAS;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,4FAA4F;AACxG;AACA;AACA;AACA,0BAA0B,2FAA2F;AACrH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,qBAAqB,SAAS;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sEAAsE,MAAM,UAAU,SAAS;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2CAA2C,eAAe;AAC1D;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,OAAO;AACvB,mEAAmE,MAAM,UAAU,SAAS;AAC5F;AACA;AACA;AACA;AACA;AACA,sEAAsE,MAAM,UAAU,SAAS;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,gBAAgB,aAAa;AAC7B;AACA;AACA;AACA,gEAAgE,+BAA+B;AAC/F;AACA;AACA;AACA,iBAAiB;AACjB;AACA,sBAAsB,SAAS;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,oEAAoE,SAAS;AAC7E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,iCAAiC,0BAA0B;AACxE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gFAAgF;AAChF;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,QAAQ;AACR;AACA;AACA,+CAA+C;AAC/C,gBAAgB,0BAA0B;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,iDAAiD;AACzE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC,4BAA4B,GAAG,GAAG;AACzE,uCAAuC,uBAAuB,GAAG,GAAG;AACpE,uCAAuC,4BAA4B,GAAG,GAAG;AACzE,uCAAuC,yBAAyB,GAAG,GAAG;AACtE,uCAAuC,4BAA4B,GAAG,GAAG;AACzE,uCAAuC,yBAAyB,GAAG,GAAG;AACtE;AACA;AACA,2BAA2B,4BAA4B,GAAG,GAAG;AAC7D,2BAA2B,uBAAuB,GAAG,GAAG;AACxD,6BAA6B,4BAA4B,GAAG,GAAG;AAC/D,6BAA6B,yBAAyB,GAAG,GAAG;AAC5D,6BAA6B,4BAA4B,GAAG,GAAG;AAC/D,6BAA6B,yBAAyB,GAAG,GAAG;AAC5D;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B;AAC3B;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,gBAAgB,UAAU,4EAA4E,aAAa;AACnH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA,0BAA0B,YAAY;AACtC,uDAAuD,YAAY;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB,YAAY;AACZ;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA,gBAAgB,UAAU;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA,8EAA8E,SAAS;AACvF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,WAAW,SAAS;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4DAA4D,kCAAkC;AAC9F;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,UAAU;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,UAAU;AAC1B;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA,+CAA+C,aAAa;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8DAA8D,MAAM;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA,+EAA+E,kCAAkC;AACjH;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA,YAAY;AACZ,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mDAAmD,0BAA0B,iDAAiD,OAAO;AACrI;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD,0BAA0B,iDAAiD,OAAO;AACvI;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB;AACvB,WAAW;AACX,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB;AACvB,WAAW;AACX,QAAQ;AACR;AACA;AACA;AACA;AACA,2EAA2E,MAAM;AACjF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C,aAAa;AAC3D;AACA;AACA;AACA;AACA;AACA,IAAI,uCAAuC;AAC3C,iBAAiB,uCAAuC;AACxD,mDAAmD,sCAAsC;AACzF;AACA;AACA,OAAO;AACP,OAAO;AACP,OAAO;AACP;AACA;AACA,OAAO;AACP,OAAO;AACP;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,OAAO;AACP,OAAO;AACP,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA,+EAA+E,iCAAiC;AAChH;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,SAAS,UAAU,SAAS;AACzF,YAAY;AACZ,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qFAAqF,YAAY;AACjG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,0BAA0B;AAC1C;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA,kDAAkD,aAAa;AAC/D;AACA;AACA,0CAA0C,MAAM,EAAE,sCAAsC,iBAAiB,OAAO;AAChH;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8EAA8E,WAAW;AACzF;AACA;AACA;AACA,8BAA8B;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA,aAAa;AACb;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uEAAuE,UAAU,UAAU,UAAU,gBAAgB,YAAY;AACjI;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B;;AAE3B;;AAEA;;AAEA;;AAEA,8CAA8C,aAAa;AAC3D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,uBAAuB;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yCAAyC,cAAc;AACvD;AACA,kDAAkD,iBAAiB;AACnE,aAAa;AACb,4DAA4D,4BAA4B;AACxF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,OAAO;AACzB;AACA;AACA;AACA,oBAAoB,qCAAqC;AACzD,oBAAoB,kBAAkB;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,kBAAkB,OAAO;AACzB;AACA;AACA;AACA,oBAAoB,6BAA6B;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wEAAwE,mBAAmB;AAC3F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uDAAuD,YAAY;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4DAA4D,mBAAmB;AAC/E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB;;AAEvB;;AAEA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iFAAiF,uBAAuB;AACxG;AACA;AACA;AACA;AACA;AACA,+EAA+E,uBAAuB;AACtG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,gBAAgB;AAC7C;AACA;AACA,+BAA+B,gBAAgB;AAC/C;AACA;AACA,0BAA0B,KAAK;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,kCAAkC;AAC/F;AACA,SAAS;AACT;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+DAA+D,kCAAkC;AACjG;AACA,SAAS;AACT;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA,yDAAyD,aAAa;AACtE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA,iGAAiG,oCAAoC;AACrI,wBAAwB,yCAAyC,oBAAoB;AACrF,8EAA8E,wCAAwC;AACtH;AACA;AACA,OAAO;AACP,OAAO;AACP,OAAO;AACP,OAAO;AACP,OAAO;AACP;AACA;AACA,OAAO;AACP,OAAO;AACP,OAAO;AACP;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,OAAO;AACP,OAAO;AACP,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iFAAiF,SAAS,UAAU,SAAS,gBAAgB,YAAY;AACzI;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4EAA4E,mCAAmC;AAC/G,YAAY;AACZ,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2DAA2D,SAAS,UAAU,SAAS;AACvF,YAAY;AACZ,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,oDAAoD;AACxE,qBAAqB;AACrB,SAAS;AACT;AACA;AACA;AACA;AACA,sCAAsC,QAAQ,oBAAoB,UAAU,oBAAoB,gBAAgB,2BAA2B;AAC3I;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,qBAAqB,QAAQ,oBAAoB,UAAU,oBAAoB,gBAAgB,2BAA2B;AAC1H;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,aAAa;AACjC;AACA;AACA;AACA;AACA,8EAA8E,QAAQ,KAAK,UAAU,MAAM;AAC3G,yFAAyF,OAAO;AAChG,kBAAkB,QAAQ,aAAa,UAAU,cAAc;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mDAAmD,aAAa;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,uDAAuD,aAAa;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,yFAAyF;AACzG;AACA;AACA,8EAA8E;AAC9E;AACA;AACA;AACA,kFAAkF,mBAAmB,UAAU,mBAAmB,gBAAgB,KAAK;AACvJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,uDAAuD,aAAa;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2FAA2F,2CAA2C;AACtI;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2FAA2F,2CAA2C;AACtI;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C;AAC7C;AACA;AACA,yDAAyD,aAAa;AACtE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yGAAyG;AACzG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,8DAA8D;AAC1F,kCAAkC;AAClC;AACA;AACA;AACA,mCAAmC;AACnC;AACA;AACA;AACA,6BAA6B;AAC7B;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC,6BAA6B;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kCAAkC;AAClC;AACA;AACA;AACA;AACA,gBAAgB,6EAA6E;AAC7F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD,6BAA6B;AAClF;AACA;AACA,gBAAgB,yCAAyC;AACzD;AACA;AACA;AACA;AACA;AACA,uCAAuC,6BAA6B;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0DAA0D,kCAAkC;AAC5F;AACA;AACA;AACA;AACA,4BAA4B,yCAAyC;AACrE;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA,qDAAqD,0DAA0D;AAC/G;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,MAAM,eAAe;AACrB,MAAM,6BAA6B;AACnC,MAAM,+BAA+B;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAiD,aAAa;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B;AAC1B,sBAAsB;AACtB,oBAAoB;AACpB,uBAAuB;AACvB;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,KAAK;AACL;AACA;AACA,2EAA2E,sCAAsC;AACjH,iCAAiC,kCAAkC;AACnE;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,OAAO;AACP,OAAO;AACP,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA,iBAAiB;AACjB;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gEAAgE,SAAS;AACzE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yEAAyE;AACzE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yEAAyE;AACzE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B;AAC5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,sFAAsF,8BAA8B;AACpH;AACA,0EAA0E,YAAY;AACtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sEAAsE,YAAY;AAClF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU,oBAAoB;AAC9B;AACA,6DAA6D,YAAY;AACzE;AACA;AACA;AACA;AACA,4BAA4B,qBAAqB;AACjD;AACA;AACA;AACA,qEAAqE,kCAAkC;AACvG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2CAA2C;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB;AACvB,gBAAgB,wBAAwB;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6FAA6F,kBAAkB,UAAU,kBAAkB,gBAAgB,uBAAuB;AAClL;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,4BAA4B,qBAAqB;AACjD;AACA;AACA;AACA,qEAAqE,sCAAsC;AAC3G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,WAAW,2BAA2B,iDAAiD,aAAa;AACpH;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;;AAEA,mDAAmD,aAAa;AAChE;AACA;AACA;AACA;AACA,MAAM,2BAA2B;AACjC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2CAA2C,WAAW;AACtD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gFAAgF,UAAU;AAC1F,gCAAgC,UAAU;AAC1C,0BAA0B,iBAAiB;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAiD,UAAU;AAC3D;AACA;AACA;AACA,mDAAmD,UAAU;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,WAAW,iEAAiE;AAC5F;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B;AACA;AACA,SAAS;AACT;AACA;AACA,gBAAgB,WAAW,kCAAkC;AAC7D,0BAA0B;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,SAAS;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,KAAK;AACnC,KAAK;AACL;AACA;;AAEA;;AAEA;AACA;AACA;AACA,MAAM,iBAAiB;AACvB;AACA;AACA;AACA,iDAAiD,aAAa;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,UAAU,sDAAsD,MAAM;AACtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB;AACvB;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC,mBAAmB;AACvD,gBAAgB,UAAU;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,UAAU,sDAAsD,MAAM;AACtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,UAAU,qDAAqD,MAAM;AACrF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD,gCAAgC;AACrF;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,UAAU,yDAAyD,MAAM;AACzF;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA,+BAA+B,oEAAoE;AACnG,4CAA4C,0EAA0E;AACtH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4FAA4F,SAAS;AACrG;AACA;AACA;;AAEA,iDAAiD,aAAa;AAC9D;AACA;AACA;AACA;AACA,oEAAoE,2BAA2B;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,iFAAiF,MAAM;AACvF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,iEAAiE,MAAM;AACvE;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,gBAAgB,oCAAoC;AACpD;AACA;AACA,EAAE;AACF;AACA;AACA,EAAE;AACF;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA,OAAO,iCAAiC;AACxC,OAAO,2BAA2B;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAE;;AAEF;;AAEA;;AAEA;;AAEA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,uDAAuD;AACpH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iEAAiE,gDAAgD;AACjH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6EAA6E,SAAS;AACtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gFAAgF,SAAS;AACzF;AACA;AACA;;AAEA,iDAAiD,aAAa;AAC9D;AACA;AACA;AACA;AACA;AACA,oEAAoE,cAAc;AAClF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,sCAAsC;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC,sCAAsC;AAC9E;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,OAAO,oBAAoB;AAC3B,OAAO,cAAc;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,oCAAoC;AACpD;AACA;AACA,EAAE;AACF;AACA;AACA,EAAE;AACF;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA,EAAE;;AAEF;;AAEA,oDAAoD,aAAa;AACjE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,QAAQ;AAC9B,QAAQ;AACR;AACA;AACA,QAAQ;AACR;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA,+DAA+D,QAAQ;AACvE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA,iEAAiE,QAAQ;AACzE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qEAAqE;AACrE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAiC,QAAQ,kBAAkB,WAAW;AACtE,QAAQ;AACR;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA,gBAAgB,WAAW,SAAS,8DAA8D,QAAQ;AAC1G;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,6CAA6C;AACtE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,oBAAoB,OAAO;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oDAAoD,KAAK;AACzD,0EAA0E,aAAa;AACvF;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC,+CAA+C;AACvF;AACA;AACA,gCAAgC;AAChC,yBAAyB;AACzB;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,mIAAmI,yBAAyB;AAC5J;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B;AAC5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+EAA+E;AAC/E;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,qIAAqI,yBAAyB;AAC9J;AACA,gBAAgB,WAAW;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,mCAAmC,8CAA8C;AACjF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC,8BAA8B;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,2BAA2B;AAC7F;AACA;AACA;AACA;AACA;AACA,4CAA4C,+CAA+C;AAC3F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,cAAc;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2DAA2D,uCAAuC;AAClG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4CAA4C,4BAA4B;AACxE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iEAAiE,4BAA4B;AAC7F;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA,mCAAmC,OAAO,IAAI,IAAI;AAClD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,iCAAiC,iDAAiD;AAClF;AACA;AACA,0CAA0C,kCAAkC;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4DAA4D,aAAa;AACzE;AACA;AACA;AACA;AACA;AACA;AACA,2FAA2F,+CAA+C;AAC1I;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,kDAAkD,uBAAuB;AACzE;AACA;AACA;AACA;AACA,kCAAkC,iDAAiD;AACnF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC,SAAS;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC,SAAS;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC;AACvC;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,gBAAgB,aAAa;AAC7B;AACA;AACA;AACA,gCAAgC;AAChC,SAAS;AACT;AACA;AACA,+EAA+E,iDAAiD;AAChI;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B;AAC/B;AACA;AACA;AACA,+BAA+B,KAAK;AACpC;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC;AACtC;AACA;AACA,yCAAyC;AACzC;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,gBAAgB,aAAa;AAC7B;AACA,gCAAgC,gDAAgD;AAChF;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uFAAuF,oCAAoC;AAC3H;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+CAA+C,wBAAwB;AACvE;AACA;AACA;AACA,4CAA4C,yBAAyB;AACrE;AACA;AACA,SAAS;AACT;AACA,iDAAiD,mBAAmB;AACpE;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA,mDAAmD,aAAa;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB;;AAExB;AACA;AACA;AACA;AACA;AACA;AACA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0EAA0E,2CAA2C;AACrH;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,cAAc;AAC9B;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,IAAI;AACJ;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uUAAuU,yCAAyC;AAChX;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B,4BAA4B;AAC3D,8BAA8B;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B;AAC5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA,wBAAwB;AACxB,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,kCAAkC;AAClC;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA,wBAAwB;AACxB,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,aAAa;AACb;AACA;AACA;AACA;AACA,sCAAsC,oBAAoB;AAC1D;AACA;AACA;AACA,sCAAsC,oBAAoB;AAC1D;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,oBAAoB,aAAa;AACjC;AACA;AACA;AACA;AACA;AACA,wBAAwB;AACxB,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD,qBAAqB;AAC1E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wDAAwD,gBAAgB;AACxE;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAiD,aAAa;AAC9D;AACA;AACA;AACA;AACA;AACA,oEAAoE,cAAc;AAClF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,cAAc;AACrC;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB,YAAY;AACZ;AACA;AACA;AACA,2DAA2D,aAAa;AACxE;AACA;AACA,uCAAuC;AACvC;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAiC;AACjC;AACA;AACA;AACA,yCAAyC;AACzC;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C;AAC7C;AACA,iEAAiE,eAAe;AAChF;AACA;AACA,aAAa;AACb,0EAA0E,6BAA6B;AACvG;AACA;AACA;AACA,iEAAiE,eAAe;AAChF;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,gBAAgB,aAAa;AAC7B,2BAA2B,YAAY;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,gBAAgB,aAAa;AAC7B,+BAA+B,YAAY;AAC3C;AACA;AACA;AACA;AACA;AACA,mEAAmE,OAAO;AAC1E;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,OAAO,oBAAoB;AAC3B,OAAO,cAAc;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,oCAAoC;AACpD;AACA;AACA,EAAE;AACF;AACA;AACA,EAAE;AACF;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA,EAAE;;AAEF,iDAAiD,aAAa;AAC9D;AACA;AACA;AACA;AACA;AACA,oEAAoE,gBAAgB;AACpF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,cAAc;AACjC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B;AAC5B;AACA,qCAAqC,cAAc;AACnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B,iBAAiB;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,WAAW;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,2CAA2C,qBAAqB;AAChE;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,WAAW;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,2CAA2C,qBAAqB;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,2BAA2B,yBAAyB;AACpD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,+BAA+B,yBAAyB;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,wBAAwB,OAAO;AAC/B;AACA,iEAAiE,gDAAgD;AACjH;AACA;AACA,6EAA6E,MAAM;AACnF;AACA,2BAA2B,MAAM;AACjC;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6EAA6E,yBAAyB;AACtG;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,gBAAgB,oCAAoC;AACpD;AACA;AACA,EAAE;AACF;AACA;AACA,EAAE;AACF;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA,OAAO,sBAAsB;AAC7B,OAAO,gBAAgB;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAE;;AAEF;;AAEA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA,aAAa,yBAAyB;AACtC;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA,0DAA0D,YAAY;AACtE;AACA;AACA,cAAc;AACd;AACA,+DAA+D,YAAY;AAC3E;AACA;AACA,cAAc;AACd;AACA,6DAA6D,YAAY;AACzE;AACA;AACA,cAAc;AACd;AACA,yFAAyF,MAAM;AAC/F;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAE;;AAEF;;AAEA;;AAEA;;AAEA,0DAA0D,aAAa;AACvE;AACA;AACA;AACA;AACA;AACA,uBAAuB;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA,kEAAkE,aAAa;AAC/E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,QAAQ;AAC1E,kEAAkE,QAAQ;AAC1E,oEAAoE,QAAQ;AAC5E,sEAAsE,QAAQ;AAC9E;AACA;AACA;AACA;AACA;AACA,iBAAiB,UAAU;AAC3B;AACA;AACA,6EAA6E,mCAAmC,aAAa,wBAAwB;AACrJ;AACA;AACA;AACA;AACA,sDAAsD,qBAAqB,EAAE,qBAAqB;AAClG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA,iBAAiB,yBAAyB;AAC1C;AACA;AACA,sDAAsD,qBAAqB,EAAE,qBAAqB;AAClG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA,iBAAiB,YAAY;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA,oGAAoG,UAAU,oBAAoB,eAAe;AACjJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,gDAAgD,aAAa;AAC7D;AACA,6BAA6B,cAAc,EAAE,WAAW;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,WAAW,mBAAmB,aAAa,IAAI,MAAM;AAC3G;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC,WAAW,MAAM,WAAW;AACpE;AACA;AACA;AACA,aAAa,aAAa;AAC1B;AACA,oCAAoC,KAAK,GAAG,MAAM,aAAa,kBAAkB,KAAK,eAAe,MAAM,WAAW;AACtH,oCAAoC,KAAK,GAAG,MAAM,aAAa,eAAe,MAAM,WAAW;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,UAAU,IAAI,MAAM;AAC1E;AACA;AACA;AACA;AACA;AACA,EAAE;;AAEF;;AAEA;;AAEA;AACA;AACA;AACA,+DAA+D,aAAa;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,aAAa;AAClC;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,iBAAiB,UAAU;AAC3B;AACA;AACA,sDAAsD,gCAAgC,EAAE,+BAA+B;AACvH;AACA;AACA;AACA,2EAA2E,mCAAmC,aAAa,wBAAwB;AACnJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,iBAAiB,cAAc;AAC/B;AACA;AACA,sDAAsD,2BAA2B,EAAE,0BAA0B;AAC7G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,yBAAyB;AAC1C;AACA;AACA,sDAAsD,2BAA2B,EAAE,0BAA0B;AAC7G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,iBAAiB,YAAY;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,kCAAkC,YAAY,2BAA2B;AAClG;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA,uGAAuG,OAAO,mBAAmB,UAAU,UAAU,4BAA4B,UAAU,4BAA4B,gBAAgB,kCAAkC;AACzQ;AACA;AACA;AACA;AACA,oGAAoG,UAAU,UAAU,4BAA4B,UAAU,4BAA4B,gBAAgB,kCAAkC;AAC5O;AACA;AACA;AACA,iBAAiB,YAAY;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oGAAoG,UAAU,oBAAoB,GAAG;AACrI;AACA;AACA;AACA;AACA,iBAAiB,YAAY;AAC7B;AACA,sDAAsD,2BAA2B,EAAE,0BAA0B;AAC7G;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;AACA,UAAU;AACV;AACA;AACA;AACA,iBAAiB,YAAY;AAC7B;AACA,sDAAsD,SAAS,EAAE,QAAQ;AACzE;AACA;AACA;AACA;AACA;AACA,iBAAiB,YAAY;AAC7B;AACA,sDAAsD,SAAS,EAAE,QAAQ;AACzE;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,kCAAkC,EAAE,iCAAiC;AAC3H;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,aAAa;AAC9B;AACA;AACA;AACA;AACA;AACA,qBAAqB,kBAAkB,mCAAmC,0BAA0B;AACpG;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,kGAAkG,OAAO,8BAA8B,iCAAiC,UAAU,iCAAiC,gBAAgB,uCAAuC;AAC1Q;AACA;AACA;AACA;AACA,iBAAiB,aAAa;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA,yDAAyD,WAAW;AACpE,kBAAkB;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wDAAwD,4BAA4B;AACpF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,aAAa;AAClC;AACA;AACA,cAAc;AACd,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C;AAC9C;AACA;AACA,sDAAsD,aAAa;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,2FAA2F,iGAAiG;AAC5L,wBAAwB,oCAAoC;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,2HAA2H;AACjJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,mBAAmB;AACzD;AACA,kEAAkE,mBAAmB;AACrF;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,SAAS;AAC3B;AACA;AACA,UAAU;AACV;AACA;AACA,qBAAqB,iBAAiB;AACtC,uCAAuC,SAAS;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,qBAAqB,EAAE,qBAAqB;AAClG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B,SAAS;AACnC;AACA;AACA,UAAU;AACV;AACA;AACA,iHAAiH,eAAe;AAChI;AACA;AACA;AACA,6EAA6E,mCAAmC,aAAa,wBAAwB;AACrJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,iBAAiB,iBAAiB;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qGAAqG,mFAAmF;AACxL;AACA;AACA;AACA;AACA;AACA,8BAA8B,wBAAwB;AACtD;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,gBAAgB;AACtE;AACA;AACA;AACA;AACA;AACA,uDAAuD,aAAa,EAAE,aAAa;AACnF;AACA;AACA;AACA,iFAAiF,aAAa,EAAE,YAAY;AAC5G;AACA;AACA;AACA,kEAAkE,gBAAgB;AAClF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kDAAkD,gBAAgB;AAClE;AACA;AACA;AACA;AACA,6BAA6B,oEAAoE;AACjG;AACA;AACA;AACA;AACA;AACA,qCAAqC,gBAAgB;AACrD;AACA;AACA,UAAU;AACV;AACA;AACA,sDAAsD,qBAAqB,EAAE,qBAAqB;AAClG;AACA;AACA,wFAAwF,eAAe;AACvG;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,yBAAyB;AAClD;AACA;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,6FAA6F;AACxH;AACA;AACA;AACA;AACA;AACA,oCAAoC,QAAQ;AAC5C;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+EAA+E,aAAa,EAAE,YAAY;AAC1G;AACA;AACA,iFAAiF,aAAa,EAAE,YAAY;AAC5G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,gFAAgF;AAC7G;AACA;AACA,oBAAoB,iBAAiB;AACrC;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,sBAAsB;AACtB,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,gBAAgB;AAC9C;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC,gBAAgB;AACnD;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wDAAwD,4CAA4C;AACpG;AACA,0DAA0D,oCAAoC;AAC9F,wEAAwE,+CAA+C;AACvH;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,sEAAsE;AACnG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,6CAA6C,YAAY;AACzD;AACA;AACA;AACA;AACA,oDAAoD,0CAA0C;AAC9F;AACA;AACA;AACA;AACA;AACA,6CAA6C,0CAA0C;AACvF;AACA;AACA;AACA;AACA,6BAA6B,iCAAiC;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA,mFAAmF,oBAAoB,GAAG,oBAAoB,GAAG,0BAA0B;AAC3J;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,wCAAwC;AACjE,wBAAwB,eAAe,IAAI,kBAAkB,IAAI,eAAe;AAChF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,wCAAwC;AACjE,wBAAwB,eAAe;AACvC,YAAY;AACZ;AACA,yBAAyB,wCAAwC;AACjE,wBAAwB,eAAe,IAAI,kBAAkB,IAAI,eAAe;AAChF,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,wCAAwC;AACjE,wBAAwB,eAAe,IAAI,kBAAkB,IAAI,eAAe;AAChF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC,aAAa;AAC7C,4DAA4D,KAAK,GAAG,MAAM;AAC1E;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,cAAc;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,WAAW,mBAAmB,cAAc,YAAY,oBAAoB,GAAG,oBAAoB,GAAG,0BAA0B;AAC7L;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC,UAAU;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2EAA2E,iGAAiG;AAC5K;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,cAAc;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wDAAwD,4CAA4C;AACpG;AACA,0DAA0D,oCAAoC;AAC9F,wEAAwE,+CAA+C;AACvH;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,uCAAuC;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,kDAAkD;AACvE;AACA;AACA;AACA;AACA,iCAAiC,yBAAyB;AAC1D;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wJAAwJ,eAAe;AACvK;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC,wBAAwB;AACxD,+BAA+B;AAC/B;AACA;AACA;AACA,qBAAqB,iBAAiB;AACtC;AACA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,YAAY;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA,oDAAoD,mDAAmD;AACvG;AACA;AACA;AACA,+CAA+C,mDAAmD;AAClG;AACA;AACA,qBAAqB,iBAAiB;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iEAAiE,WAAW,aAAa,oBAAoB,GAAG,oBAAoB,GAAG,0BAA0B;AACjK;AACA;AACA;AACA;AACA,4BAA4B,WAAW;AACvC;AACA;AACA;AACA;AACA;AACA,qCAAqC,uBAAuB;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA,sBAAsB;AACtB;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,KAAK;AAC1B;AACA;AACA;AACA,0BAA0B;AAC1B;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA,0BAA0B;AAC1B;AACA;AACA;AACA,sBAAsB;AACtB;AACA,kBAAkB;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kFAAkF,MAAM;AACxF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,oBAAoB,IAAI,oBAAoB;AAC9G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;AACA,cAAc;AACd;AACA,UAAU;AACV;AACA;AACA,4CAA4C,OAAO,uBAAuB,oBAAoB,IAAI,oBAAoB;AACtH;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,qBAAqB,YAAY;AACjC;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mEAAmE,aAAa;AAChF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,iEAAiE,QAAQ;AACzE;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,iEAAiE,QAAQ;AACzE;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,wDAAwD,QAAQ,GAAG,YAAY,GAAG,4BAA4B;AAC9G;AACA;AACA,wDAAwD,QAAQ;AAChE;AACA;AACA,kEAAkE,QAAQ,KAAK,wBAAwB;AACvG,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA,wEAAwE,QAAQ,KAAK,WAAW;AAChG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,eAAe,oCAAoC;AACnD;AACA;AACA,CAAC;AACD;AACA;AACA,CAAC;AACD;AACA,0CAA0C,4BAA4B;AACtE,CAAC;AACD;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8DAA8D,aAAa;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mDAAmD,SAAS;AAC5D;AACA;AACA,2DAA2D,aAAa;AACxE;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAiD,QAAQ,GAAG,YAAY,GAAG,qBAAqB;AAChG;AACA;AACA,iDAAiD,QAAQ,GAAG,qBAAqB;AACjF;AACA;AACA,2BAA2B;AAC3B;AACA,4DAA4D,wBAAwB;AACpF;AACA;AACA;AACA;AACA;AACA;AACA,sEAAsE,WAAW;AACjF;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,WAAW;AAC7E;AACA;AACA;AACA,0DAA0D,QAAQ,GAAG,qBAAqB;AAC1F;AACA,2BAA2B;AAC3B;AACA,2DAA2D,WAAW;AACtE;AACA;AACA;AACA,iDAAiD,QAAQ,GAAG,qBAAqB;AACjF;AACA,2BAA2B;AAC3B;AACA,2DAA2D,WAAW;AACtE;AACA;AACA;AACA,kDAAkD,QAAQ,GAAG,qBAAqB;AAClF;AACA,2BAA2B;AAC3B;AACA,4DAA4D,WAAW;AACvE;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,8CAA8C;AAC9C;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC,SAAS,sBAAsB,aAAa,8BAA8B,YAAY,wDAAwD,aAAa;AAC9L;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAE,gEAAgE;AAClE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAE,oDAAoD;AACtD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD,WAAW;AAChE;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,WAAW;AAC5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C;AAC7C;AACA;AACA,6CAA6C,WAAW;AACxD;AACA,UAAU;AACV,MAAM;AACN;AACA,8BAA8B,8CAA8C,IAAI;AAChF,kCAAkC,kCAAkC,IAAI;AACxE;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,QAAQ;AACzB;AACA;AACA;AACA;AACA,qBAAqB,WAAW;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA,EAAE;;AAEF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C;AAC9C;AACA;AACA,mDAAmD,aAAa;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,iGAAiG,cAAc;AAC/G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB;AACtB,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,yBAAyB,aAAa;AACtC;AACA,cAAc;AACd,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,mCAAmC;AACzE,SAAS,kFAAkF;AAC3F;AACA,kCAAkC,qBAAqB,IAAI,gBAAgB;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,0BAA0B;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,qBAAqB,oCAAoC;AACzD,qBAAqB,WAAW;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uIAAuI,sEAAsE;AAC7M;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,iBAAiB,mCAAmC;AACpD,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,yDAAyD,uBAAuB;AAChF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,6DAA6D,wBAAwB,eAAe;AACpG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,kCAAkC,kBAAkB;AACpD;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,mCAAmC;AACzE,SAAS,oFAAoF;AAC7F;AACA,kCAAkC,qBAAqB,IAAI,gBAAgB;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,0BAA0B;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+GAA+G,eAAe,qBAAqB;AACnJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,yBAAyB,2BAA2B;AACpD,mDAAmD,SAAS;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,yDAAyD,mCAAmC,cAAc;AAC1G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,wCAAwC,qBAAqB,eAAe;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,mHAAmH,eAAe,qBAAqB;AACvJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,mHAAmH,eAAe,qBAAqB;AACvJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,oCAAoC;AACzD,qBAAqB,qCAAqC;AAC1D;AACA;AACA,iDAAiD,oBAAoB,IAAI;AACzE;AACA;AACA;AACA;AACA;AACA,wCAAwC;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4EAA4E,oBAAoB;AAChG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0GAA0G,WAAW;AACrH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB;AACtB,UAAU;AACV;AACA;AACA;AACA;AACA,gCAAgC,iDAAiD;AACjF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC,iDAAiD;AACjF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4FAA4F,oBAAoB;AAChH;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C;AAC9C;AACA;AACA,sDAAsD,aAAa;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+CAA+C;AAC/C,sGAAsG;AACtG;AACA;AACA;AACA;AACA,iBAAiB,8CAA8C;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR,QAAQ;AACR,QAAQ;AACR,QAAQ;AACR;AACA;AACA;AACA,QAAQ;AACR,QAAQ;AACR,QAAQ;AACR,QAAQ;AACR,QAAQ;AACR;AACA;AACA,QAAQ;AACR,QAAQ;AACR,QAAQ;AACR,QAAQ;AACR,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC,yBAAyB,QAAQ;AACxE;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,gDAAgD,SAAS;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,WAAW;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,WAAW;AAC/B;AACA;AACA;AACA;AACA,oBAAoB,WAAW;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,WAAW;AAC/B;AACA;AACA;AACA;AACA,oBAAoB,WAAW;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA,iDAAiD,YAAY,GAAG,0BAA0B;AAC1F;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,wBAAwB;AACrF;AACA;AACA;AACA,iEAAiE,WAAW;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,sDAAsD,wBAAwB;AAC9E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,4DAA4D,QAAQ;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,iEAAiE,gBAAgB;AACjF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,4DAA4D,gBAAgB;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B,+BAA+B;AACzD;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,UAAU;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,6CAA6C,WAAW;AACxD;AACA;AACA;AACA,gEAAgE,uBAAuB;AACvF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0CAA0C,0BAA0B,gBAAgB;AACpF;AACA;AACA;AACA;AACA,0CAA0C,uBAAuB,kBAAkB;AACnF,0CAA0C,0BAA0B,gBAAgB;AACpF;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,uDAAuD,aAAa;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,+CAA+C;AACrG,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA,0CAA0C,WAAW;AACrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,cAAc;AACnC;AACA,cAAc;AACd;AACA,8EAA8E,sBAAsB;AACpG;AACA;AACA;AACA;AACA;AACA;AACA,2FAA2F,sBAAsB,KAAK,MAAM;AAC5H;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,yBAAyB;AAC7C,4DAA4D,YAAY;AACxE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,qBAAqB,OAAO;AAC5B,wBAAwB,iEAAiE;AACzF,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mEAAmE,QAAQ;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA,sDAAsD,aAAa;AACnE;AACA;AACA,iDAAiD,0BAA0B;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA,kPAAkP,yBAAyB;AAC3Q;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,8CAA8C;AAC9C;AACA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oGAAoG,yBAAyB;AAC7H;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA,kFAAkF,KAAK;AACvF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,mFAAmF,KAAK;AACxF;AACA,cAAc;AACd,UAAU;AACV;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,qBAAqB;AAC7B,QAAQ,qBAAqB,KAAK,qBAAqB;AACvD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,oCAAoC;AACrD;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA;AACA,iDAAiD,aAAa;AAC9D;AACA;AACA;AACA,GAAG;AACH;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA,6CAA6C,aAAa;AAC1D;AACA;AACA,gDAAgD,cAAc,EAAE,QAAQ;AACxE;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wDAAwD,uCAAuC;AAC/F;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,iGAAiG,aAAa;AAC9G;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC,kDAAkD;AACrF;AACA;AACA;AACA;AACA;AACA;AACA,iCAAiC,cAAc;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gEAAgE,oDAAoD;AACpH;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,kEAAkE,oDAAoD;AACtH;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,mDAAmD,UAAU;AAC7D;AACA;AACA;AACA;;AAEA,+CAA+C,aAAa;AAC5D;AACA;AACA;AACA;AACA;AACA,oEAAoE,sBAAsB;AAC1F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB,SAAS;AACT,8CAA8C,UAAU;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,OAAO,4BAA4B;AACnC,OAAO,sBAAsB;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,oCAAoC;AACpD;AACA;AACA,EAAE;AACF;AACA;AACA,EAAE;AACF;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA,EAAE;;AAEF,6CAA6C,aAAa;AAC1D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;;AAEA;;AAEA;;AAEA,4CAA4C,aAAa;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mEAAmE,wBAAwB;AAC3F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,uDAAuD,aAAa;AACpE;AACA;AACA;AACA;AACA;AACA,YAAY,QAAQ;AACpB;AACA,gBAAgB,aAAa;AAC7B;AACA;AACA;AACA,gBAAgB,OAAO;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,UAAU;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C;AAC7C;AACA;AACA,iDAAiD,aAAa;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,YAAY;AACxC,6BAA6B,wCAAwC;AACrE;AACA;AACA;AACA,SAAS;AACT,gBAAgB,aAAa;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC,sCAAsC,KAAK,GAAG;AACtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,gBAAgB;AAChC,iCAAiC;AACjC;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,qCAAqC,mBAAmB;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA,yCAAyC,qBAAqB;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,sBAAsB;AAC1C;AACA,6BAA6B,wHAAwH;AACrJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAiC,kCAAkC;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,uDAAuD,aAAa;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kCAAkC,cAAc;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,KAAK;;AAEL,eAAe;AACf,kBAAe;AACf,WAAW;;;;;;;;;;;;AC7niBX;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEa;;AAEb;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,EAAE;AACF;AACA;AACA;AACA;AACA,EAAE;AACF;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,mBAAmB;;AAEnB;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,kBAAkB,sBAAsB;AACxC;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA,eAAe;AACf;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA,IAAI;AACJ;AACA;AACA,oBAAoB,SAAS;AAC7B;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA,MAAM;AACN;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;;AAEA,kCAAkC,QAAQ;AAC1C;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,oBAAoB,iBAAiB;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA,QAAQ;AACR;AACA,uCAAuC,QAAQ;AAC/C;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,MAAM;AACN;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,kBAAkB,OAAO;AACzB;AACA;AACA;;AAEA;AACA,SAAS,yBAAyB;AAClC;AACA;AACA;;AAEA;AACA;AACA,kBAAkB,gBAAgB;AAClC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA,8DAA8D,YAAY;AAC1E;AACA,8DAA8D,YAAY;AAC1E;AACA,GAAG;AACH;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA,qCAAqC,YAAY;AACjD;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,IAAI;AACJ;AACA;AACA;;;;;;;;;;;AChfA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,WAAW,mBAAO,CAAC,mDAAS;;AAE5B;AACA;;AAEA;;;;;;;;;;;ACNA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,cAAc,mBAAO,CAAC,yDAAY;AAClC,cAAc,mBAAO,CAAC,yDAAY;AAClC,cAAc,mBAAO,CAAC,yDAAY;;AAElC;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC/BA,qBAAqB,mBAAO,CAAC,uEAAmB;AAChD,sBAAsB,mBAAO,CAAC,yEAAoB;AAClD,mBAAmB,mBAAO,CAAC,mEAAiB;AAC5C,mBAAmB,mBAAO,CAAC,mEAAiB;AAC5C,mBAAmB,mBAAO,CAAC,mEAAiB;;AAE5C;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC/BA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,WAAW,mBAAO,CAAC,mDAAS;;AAE5B;AACA;;AAEA;;;;;;;;;;;ACNA,oBAAoB,mBAAO,CAAC,qEAAkB;AAC9C,qBAAqB,mBAAO,CAAC,uEAAmB;AAChD,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,kBAAkB,mBAAO,CAAC,iEAAgB;;AAE1C;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC/BA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,WAAW,mBAAO,CAAC,mDAAS;;AAE5B;AACA;;AAEA;;;;;;;;;;;ACNA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,WAAW,mBAAO,CAAC,mDAAS;;AAE5B;AACA;;AAEA;;;;;;;;;;;ACNA,eAAe,mBAAO,CAAC,2DAAa;AACpC,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,kBAAkB,mBAAO,CAAC,iEAAgB;;AAE1C;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;;;;;;;;;;AC1BA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,eAAe,mBAAO,CAAC,2DAAa;AACpC,eAAe,mBAAO,CAAC,2DAAa;AACpC,eAAe,mBAAO,CAAC,2DAAa;;AAEpC;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC1BA,WAAW,mBAAO,CAAC,mDAAS;;AAE5B;AACA;;AAEA;;;;;;;;;;;ACLA,WAAW,mBAAO,CAAC,mDAAS;;AAE5B;AACA;;AAEA;;;;;;;;;;;ACLA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,WAAW,mBAAO,CAAC,mDAAS;;AAE5B;AACA;;AAEA;;;;;;;;;;;ACNA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,UAAU;AACrB,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACrBA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,UAAU;AACrB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACxBA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,kBAAkB,mBAAO,CAAC,+DAAe;AACzC,cAAc,mBAAO,CAAC,uDAAW;AACjC,eAAe,mBAAO,CAAC,yDAAY;AACnC,cAAc,mBAAO,CAAC,yDAAY;AAClC,mBAAmB,mBAAO,CAAC,iEAAgB;;AAE3C;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,WAAW,SAAS;AACpB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AChDA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACnBA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,UAAU;AACrB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACtBA,sBAAsB,mBAAO,CAAC,yEAAoB;AAClD,SAAS,mBAAO,CAAC,6CAAM;;AAEvB;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,GAAG;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC3BA,SAAS,mBAAO,CAAC,6CAAM;;AAEvB;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,GAAG;AACd,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACpBA,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,WAAW,mBAAO,CAAC,iDAAQ;;AAE3B;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AChBA,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,aAAa,mBAAO,CAAC,qDAAU;;AAE/B;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AChBA,qBAAqB,mBAAO,CAAC,uEAAmB;;AAEhD;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,GAAG;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,IAAI;AACJ;AACA;AACA;;AAEA;;;;;;;;;;;ACxBA,YAAY,mBAAO,CAAC,qDAAU;AAC9B,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,mBAAmB,mBAAO,CAAC,mEAAiB;AAC5C,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,oBAAoB,mBAAO,CAAC,qEAAkB;AAC9C,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,mBAAmB,mBAAO,CAAC,mEAAiB;AAC5C,aAAa,mBAAO,CAAC,uDAAW;AAChC,qBAAqB,mBAAO,CAAC,uEAAmB;AAChD,qBAAqB,mBAAO,CAAC,uEAAmB;AAChD,sBAAsB,mBAAO,CAAC,yEAAoB;AAClD,cAAc,mBAAO,CAAC,uDAAW;AACjC,eAAe,mBAAO,CAAC,yDAAY;AACnC,YAAY,mBAAO,CAAC,mDAAS;AAC7B,eAAe,mBAAO,CAAC,yDAAY;AACnC,YAAY,mBAAO,CAAC,mDAAS;AAC7B,WAAW,mBAAO,CAAC,iDAAQ;AAC3B,aAAa,mBAAO,CAAC,qDAAU;;AAE/B;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,WAAW,SAAS;AACpB;AACA;AACA;AACA,WAAW,UAAU;AACrB,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,aAAa,GAAG;AAChB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;;AAEA;AACA;AACA;AACA;AACA,uCAAuC;AACvC;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;AACL,IAAI;AACJ;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;;AAEA;;;;;;;;;;;ACrKA,eAAe,mBAAO,CAAC,yDAAY;;AAEnC;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;;;;;;;;;;;AC7BA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,cAAc,mBAAO,CAAC,uDAAW;;AAEjC;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,UAAU;AACrB,WAAW,UAAU;AACrB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACnBA,aAAa,mBAAO,CAAC,uDAAW;AAChC,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,qBAAqB,mBAAO,CAAC,uEAAmB;;AAEhD;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC3BA,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,mBAAmB,mBAAO,CAAC,iEAAgB;;AAE3C;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACjBA,sBAAsB,mBAAO,CAAC,yEAAoB;AAClD,mBAAmB,mBAAO,CAAC,iEAAgB;;AAE3C;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,WAAW,GAAG;AACd,WAAW,SAAS;AACpB;AACA;AACA,WAAW,UAAU;AACrB,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC3BA,YAAY,mBAAO,CAAC,qDAAU;AAC9B,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,mBAAmB,mBAAO,CAAC,mEAAiB;AAC5C,aAAa,mBAAO,CAAC,uDAAW;AAChC,cAAc,mBAAO,CAAC,uDAAW;AACjC,eAAe,mBAAO,CAAC,yDAAY;AACnC,mBAAmB,mBAAO,CAAC,iEAAgB;;AAE3C;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,UAAU;AACrB,WAAW,UAAU;AACrB,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AClFA,aAAa,mBAAO,CAAC,uDAAW;AAChC,mBAAmB,mBAAO,CAAC,iEAAgB;;AAE3C;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACjBA,iBAAiB,mBAAO,CAAC,6DAAc;AACvC,eAAe,mBAAO,CAAC,2DAAa;AACpC,eAAe,mBAAO,CAAC,yDAAY;AACnC,eAAe,mBAAO,CAAC,2DAAa;;AAEpC;AACA;AACA;AACA;AACA,oCAAoC;;AAEpC;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC9CA,aAAa,mBAAO,CAAC,uDAAW;AAChC,mBAAmB,mBAAO,CAAC,iEAAgB;;AAE3C;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACjBA,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,eAAe,mBAAO,CAAC,yDAAY;AACnC,mBAAmB,mBAAO,CAAC,iEAAgB;;AAE3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC3DA,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC7BA,eAAe,mBAAO,CAAC,yDAAY;AACnC,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,mBAAmB,mBAAO,CAAC,mEAAiB;;AAE5C;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AChCA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,UAAU;AACrB,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACnBA;AACA;AACA;AACA;AACA,WAAW,UAAU;AACrB,aAAa,UAAU;AACvB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACbA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACZA,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA;AACA;AACA;AACA,WAAW,aAAa;AACxB,aAAa,aAAa;AAC1B;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;ACfA,WAAW,mBAAO,CAAC,mDAAS;;AAE5B;AACA,kBAAkB,KAA0B;;AAE5C;AACA,gCAAgC,QAAa;;AAE7C;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,SAAS;AACpB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;;;;;;;;;;AClCA,uBAAuB,mBAAO,CAAC,2EAAqB;;AAEpD;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,SAAS;AACpB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACfA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AChBA,aAAa,mBAAO,CAAC,uDAAW;;AAEhC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACjBA,uBAAuB,mBAAO,CAAC,2EAAqB;;AAEpD;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,SAAS;AACpB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACfA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACnBA,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,sBAAsB,mBAAO,CAAC,yEAAoB;;AAElD;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,OAAO;AAClB,WAAW,QAAQ,UAAU;AAC7B,WAAW,UAAU;AACrB,aAAa,QAAQ;AACrB;AACA;AACA;AACA,wBAAwB;;AAExB;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACvCA,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ,UAAU;AAC7B,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACfA,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,mBAAmB,mBAAO,CAAC,mEAAiB;;AAE5C;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ,UAAU;AAC7B,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACfA,WAAW,mBAAO,CAAC,mDAAS;;AAE5B;AACA;;AAEA;;;;;;;;;;;ACLA,gBAAgB,mBAAO,CAAC,6DAAc;;AAEtC;AACA;AACA;AACA,WAAW,QAAQ;AACnB;AACA,IAAI;AACJ,CAAC;;AAED;;;;;;;;;;;ACVA,eAAe,mBAAO,CAAC,2DAAa;AACpC,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,eAAe,mBAAO,CAAC,2DAAa;;AAEpC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,QAAQ;AACnB,WAAW,UAAU;AACrB,WAAW,UAAU;AACrB,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACnFA,aAAa,mBAAO,CAAC,uDAAW;AAChC,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,SAAS,mBAAO,CAAC,6CAAM;AACvB,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,UAAU;AACrB,WAAW,UAAU;AACrB,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC/GA,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,UAAU;AACrB,WAAW,UAAU;AACrB,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACzFA;AACA,wBAAwB,qBAAM,gBAAgB,qBAAM,IAAI,qBAAM,sBAAsB,qBAAM;;AAE1F;;;;;;;;;;;ACHA,qBAAqB,mBAAO,CAAC,uEAAmB;AAChD,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,WAAW,mBAAO,CAAC,iDAAQ;;AAE3B;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACfA,qBAAqB,mBAAO,CAAC,uEAAmB;AAChD,mBAAmB,mBAAO,CAAC,mEAAiB;AAC5C,aAAa,mBAAO,CAAC,qDAAU;;AAE/B;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AChBA,gBAAgB,mBAAO,CAAC,6DAAc;;AAEtC;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,aAAa,GAAG;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACjBA,mBAAmB,mBAAO,CAAC,mEAAiB;AAC5C,eAAe,mBAAO,CAAC,2DAAa;;AAEpC;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,aAAa,GAAG;AAChB;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AChBA,cAAc,mBAAO,CAAC,yDAAY;;AAElC;AACA;;AAEA;;;;;;;;;;;ACLA,aAAa,mBAAO,CAAC,uDAAW;;AAEhC;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,IAAI;;AAEJ;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC7CA,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,gBAAgB,mBAAO,CAAC,2DAAa;;AAErC;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;;;;;;;;;;;AC7BA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,mBAAmB,mBAAO,CAAC,mEAAiB;AAC5C,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,gBAAgB,mBAAO,CAAC,2DAAa;;AAErC;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACxBA,eAAe,mBAAO,CAAC,2DAAa;AACpC,UAAU,mBAAO,CAAC,iDAAQ;AAC1B,cAAc,mBAAO,CAAC,yDAAY;AAClC,UAAU,mBAAO,CAAC,iDAAQ;AAC1B,cAAc,mBAAO,CAAC,yDAAY;AAClC,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,eAAe,mBAAO,CAAC,2DAAa;;AAEpC;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,QAAQ;AACrB;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACzDA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,aAAa,GAAG;AAChB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACZA,mBAAmB,mBAAO,CAAC,mEAAiB;;AAE5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AChBA,mBAAmB,mBAAO,CAAC,mEAAiB;;AAE5C;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,GAAG;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC7BA,mBAAmB,mBAAO,CAAC,mEAAiB;;AAE5C;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACtBA,mBAAmB,mBAAO,CAAC,mEAAiB;;AAE5C;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,GAAG;AACd,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACtBA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACzBA,uBAAuB,mBAAO,CAAC,2EAAqB;AACpD,oBAAoB,mBAAO,CAAC,qEAAkB;AAC9C,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,sBAAsB,mBAAO,CAAC,yEAAoB;;AAElD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,SAAS;AACpB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC5EA,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,mBAAmB,mBAAO,CAAC,mEAAiB;AAC5C,kBAAkB,mBAAO,CAAC,iEAAgB;;AAE1C;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACjBA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACxBA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACdA,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA,WAAW,UAAU;AACrB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACnBA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;;;;;;;;;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACZA,mBAAmB,mBAAO,CAAC,mEAAiB;;AAE5C;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AClCA,mBAAmB,mBAAO,CAAC,mEAAiB;;AAE5C;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,GAAG;AAChB;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;;;;;;;;;;AClBA,mBAAmB,mBAAO,CAAC,mEAAiB;;AAE5C;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACfA,mBAAmB,mBAAO,CAAC,mEAAiB;;AAE5C;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,GAAG;AACd,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACzBA,WAAW,mBAAO,CAAC,mDAAS;AAC5B,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,UAAU,mBAAO,CAAC,iDAAQ;;AAE1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACpBA,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACjBA,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,GAAG;AAChB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACfA,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACfA,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,GAAG;AACd,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACrBA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;AACA;AACA,GAAG;AACH;AACA;;AAEA;;;;;;;;;;;ACjBA,gBAAgB,mBAAO,CAAC,6DAAc;;AAEtC;AACA;;AAEA;;;;;;;;;;;ACLA,cAAc,mBAAO,CAAC,yDAAY;;AAElC;AACA;;AAEA;;;;;;;;;;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;ACnBA,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA,kBAAkB,KAA0B;;AAE5C;AACA,gCAAgC,QAAa;;AAE7C;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,IAAI;AACJ,CAAC;;AAED;;;;;;;;;;;AC7BA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACrBA;AACA;AACA;AACA;AACA,WAAW,UAAU;AACrB,WAAW,UAAU;AACrB,aAAa,UAAU;AACvB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACdA,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA;;AAEA;AACA;;AAEA;;;;;;;;;;;ACRA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AClBA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACbA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;AACA;AACA,GAAG;AACH;AACA;;AAEA;;;;;;;;;;;ACjBA,gBAAgB,mBAAO,CAAC,6DAAc;;AAEtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;;;;;;;;;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,GAAG;AAChB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACbA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,UAAU,mBAAO,CAAC,iDAAQ;AAC1B,eAAe,mBAAO,CAAC,2DAAa;;AAEpC;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,GAAG;AACd,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACjCA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,UAAU;AACrB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA,MAAM;AACN;AACA;AACA;;AAEA;;;;;;;;;;;ACzBA,gBAAgB,mBAAO,CAAC,6DAAc;;AAEtC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,GAAG;AAChB;AACA;AACA;AACA,oBAAoB,QAAQ,IAAI,QAAQ;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA,kBAAkB;AAClB,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACpCA,sBAAsB,mBAAO,CAAC,yEAAoB;AAClD,mBAAmB,mBAAO,CAAC,iEAAgB;;AAE3C;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA,8BAA8B,mBAAmB;AACjD;AACA;AACA;AACA;AACA;AACA,+CAA+C,mBAAmB;AAClE;AACA;AACA;;AAEA;;;;;;;;;;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACzBA,iBAAiB,mBAAO,CAAC,6DAAc;AACvC,eAAe,mBAAO,CAAC,yDAAY;;AAEnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;AChCA,WAAW,mBAAO,CAAC,mDAAS;AAC5B,gBAAgB,mBAAO,CAAC,2DAAa;;AAErC;AACA,kBAAkB,KAA0B;;AAE5C;AACA,gCAAgC,QAAa;;AAE7C;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACrCA,kBAAkB,mBAAO,CAAC,iEAAgB;;AAE1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA,kBAAkB;AAClB,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AClCA,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,eAAe,mBAAO,CAAC,yDAAY;;AAEnC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACpCA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AClCA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,eAAe,mBAAO,CAAC,2DAAa;;AAEpC;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA,oBAAoB;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC5BA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,eAAe,mBAAO,CAAC,2DAAa;;AAEpC;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC1BA,uBAAuB,mBAAO,CAAC,2EAAqB;AACpD,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,eAAe,mBAAO,CAAC,2DAAa;;AAEpC;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC1BA,oBAAoB,mBAAO,CAAC,qEAAkB;AAC9C,eAAe,mBAAO,CAAC,2DAAa;AACpC,kBAAkB,mBAAO,CAAC,+DAAe;;AAEzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACpCA,oBAAoB,mBAAO,CAAC,qEAAkB;AAC9C,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,kBAAkB,mBAAO,CAAC,+DAAe;;AAEzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;UCjBA;UACA;;UAEA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;;UAEA;UACA;;UAEA;UACA;;UAEA;UACA;UACA;;;;;WCzBA;WACA;WACA;WACA;WACA,GAAG;WACH;WACA;WACA,CAAC;;;;;WCPD;WACA;WACA;WACA,uDAAuD,iBAAiB;WACxE;WACA,gDAAgD,aAAa;WAC7D;;;;;WCNA;WACA;WACA;WACA;WACA;;;;;;;;;;;;;ACHoC;AAEpC,IAAI,QAAgB,CAAC;AACrB,IAAI,WAAmB,CAAC;AACxB,IAAI,YAAkB,CAAC;AAEvB,QAAQ,CAAC,gBAAgB,CAAC,kBAAkB,EAAE,KAAK,IAAI,EAAE;IACxD,IAAI,CAAC;QACJ,MAAM,OAAO,EAAE,CAAC;IACjB,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QAChB,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACtB,CAAC;AACF,CAAC,CAAC,CAAC;AAEH;;GAEG;AACH,KAAK,UAAU,OAAO;IACrB,MAAM,cAAc,GAAG,QAAQ,CAAC,aAAa,CAAoB,WAAW,CAAC,CAAC;IAC9E,IAAI,cAAc,EAAE,CAAC;QACpB,MAAM,iBAAiB,CAAC,cAAc,CAAC,CAAC;QACxC,cAAc,CAAC,gBAAgB,CAAC,QAAQ,EAAE,KAAK,EAAE,oBAAoB,EAAE,EAAE;YACxE,QAAQ,GAAI,oBAAoB,CAAC,MAA4B,CAAC,KAAK,CAAC;QACrE,CAAC,CAAC,CAAC;IACJ,CAAC;IAED,MAAM,MAAM,GAAG,QAAQ,CAAC,aAAa,CAAkB,cAAc,CAAC,CAAC;IACvE,IAAI,MAAM,EAAE,CAAC;QACZ,MAAM,CAAC,gBAAgB,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAC;IAClD,CAAC;IACD,MAAM,aAAa,GAAG,QAAQ,CAAC,aAAa,CAAoB,eAAe,CAAC,CAAC;IACjF,IAAI,aAAa,EAAE,CAAC;QACnB,aAAa,CAAC,gBAAgB,CAAC,OAAO,EAAE,mBAAmB,CAAC,CAAC;IAC9D,CAAC;AACF,CAAC;AAED;;;;;;;GAOG;AACH,KAAK,UAAU,aAAa,CAAC,WAAkB;IAC9C,WAAW,CAAC,cAAc,EAAE,CAAC;IAC7B,IAAI,CAAC,QAAQ,EAAE,CAAC;QACf,QAAQ,GAAG,WAAW,CAAC;IACxB,CAAC;IACD,MAAM,QAAQ,GAAG,IAAI,QAAQ,EAAE,CAAC;IAChC,WAAW,GAAG,MAAM,cAAc,CAAC,QAAQ,CAAC,CAAC;IAC7C,YAAY,GAAG,IAAI,IAAI,CAAC,CAAC,WAAW,CAAC,EAAE,QAAQ,EAAE,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC,CAAC;IACzE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IACtC,QAAQ,CAAC,MAAM,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;IACtC,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,8CAAG,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC;IACrC,MAAM,WAAW,GAAG,MAAM,KAAK,CAAC,+BAA+B,EAAE;QAChE,MAAM,EAAE,MAAM;QACd,IAAI,EAAE,QAAQ;KACd,CAAC,CAAC;IAEH,MAAM,eAAe,GAAG,MAAM,WAAW,CAAC,IAAI,EAAE,CAAC;IACjD,MAAM,qBAAqB,GAAG,IAAI,CAAC,SAAS,CAAC,eAAe,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;IACvE,MAAM,IAAI,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC,kBAAkB,EAAE,KAAK,qBAAqB,IAAI,CAAC;IAC9E,MAAM,UAAU,GAAG,QAAQ,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;IACtD,IAAI,UAAU,EAAE,CAAC;QAChB,UAAU,CAAC,WAAW,IAAI,IAAI,CAAC;IAChC,CAAC;AACF,CAAC;AAED;;GAEG;AACH,KAAK,UAAU,mBAAmB;IACjC,IAAI,CAAC;QACJ,MAAM,cAAc,GAAG,MAAM,8CAAG,CAAC,WAAW,CAAC,cAAc,EAAE,CAAC,kBAAkB,EAAE,CAAC;QACnF,OAAO,CAAC,GAAG,CAAC,WAAW,cAAc,CAAC,KAAK,EAAE,CAAC,CAAC;IAChD,CAAC;IAAC,MAAM,CAAC;QACR,8BAA8B;IAC/B,CAAC;AACF,CAAC;AAED;;;;GAIG;AACH,KAAK,UAAU,cAAc,CAAC,IAAY;IACzC,MAAM,GAAG,GAAG,MAAM,8CAAG,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;IAC9C,OAAO,GAAG,CAAC;AACZ,CAAC;AAED;;;GAGG;AACH,KAAK,UAAU,iBAAiB,CAAC,aAAgC;IAChE,MAAM,OAAO,GAAsB,MAAM,8CAAG,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;IAEjE,KAAK,MAAM,GAAG,IAAI,OAAO,EAAE,CAAC;QAC3B,MAAM,UAAU,GAAsB,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;QACvE,UAAU,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,CAAC;QACzB,UAAU,CAAC,WAAW,GAAG,GAAG,CAAC,IAAI,CAAC;QAClC,UAAU,CAAC,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC;QAC5B,aAAa,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;IAClC,CAAC;AACF,CAAC","sources":["webpack://use-logging-apis/../../node_modules/@openfin/core/out/mock.js","webpack://use-logging-apis/../../node_modules/events/events.js","webpack://use-logging-apis/../../node_modules/lodash/_DataView.js","webpack://use-logging-apis/../../node_modules/lodash/_Hash.js","webpack://use-logging-apis/../../node_modules/lodash/_ListCache.js","webpack://use-logging-apis/../../node_modules/lodash/_Map.js","webpack://use-logging-apis/../../node_modules/lodash/_MapCache.js","webpack://use-logging-apis/../../node_modules/lodash/_Promise.js","webpack://use-logging-apis/../../node_modules/lodash/_Set.js","webpack://use-logging-apis/../../node_modules/lodash/_SetCache.js","webpack://use-logging-apis/../../node_modules/lodash/_Stack.js","webpack://use-logging-apis/../../node_modules/lodash/_Symbol.js","webpack://use-logging-apis/../../node_modules/lodash/_Uint8Array.js","webpack://use-logging-apis/../../node_modules/lodash/_WeakMap.js","webpack://use-logging-apis/../../node_modules/lodash/_arrayEach.js","webpack://use-logging-apis/../../node_modules/lodash/_arrayFilter.js","webpack://use-logging-apis/../../node_modules/lodash/_arrayLikeKeys.js","webpack://use-logging-apis/../../node_modules/lodash/_arrayPush.js","webpack://use-logging-apis/../../node_modules/lodash/_arraySome.js","webpack://use-logging-apis/../../node_modules/lodash/_assignValue.js","webpack://use-logging-apis/../../node_modules/lodash/_assocIndexOf.js","webpack://use-logging-apis/../../node_modules/lodash/_baseAssign.js","webpack://use-logging-apis/../../node_modules/lodash/_baseAssignIn.js","webpack://use-logging-apis/../../node_modules/lodash/_baseAssignValue.js","webpack://use-logging-apis/../../node_modules/lodash/_baseClone.js","webpack://use-logging-apis/../../node_modules/lodash/_baseCreate.js","webpack://use-logging-apis/../../node_modules/lodash/_baseGetAllKeys.js","webpack://use-logging-apis/../../node_modules/lodash/_baseGetTag.js","webpack://use-logging-apis/../../node_modules/lodash/_baseIsArguments.js","webpack://use-logging-apis/../../node_modules/lodash/_baseIsEqual.js","webpack://use-logging-apis/../../node_modules/lodash/_baseIsEqualDeep.js","webpack://use-logging-apis/../../node_modules/lodash/_baseIsMap.js","webpack://use-logging-apis/../../node_modules/lodash/_baseIsNative.js","webpack://use-logging-apis/../../node_modules/lodash/_baseIsSet.js","webpack://use-logging-apis/../../node_modules/lodash/_baseIsTypedArray.js","webpack://use-logging-apis/../../node_modules/lodash/_baseKeys.js","webpack://use-logging-apis/../../node_modules/lodash/_baseKeysIn.js","webpack://use-logging-apis/../../node_modules/lodash/_baseTimes.js","webpack://use-logging-apis/../../node_modules/lodash/_baseUnary.js","webpack://use-logging-apis/../../node_modules/lodash/_cacheHas.js","webpack://use-logging-apis/../../node_modules/lodash/_cloneArrayBuffer.js","webpack://use-logging-apis/../../node_modules/lodash/_cloneBuffer.js","webpack://use-logging-apis/../../node_modules/lodash/_cloneDataView.js","webpack://use-logging-apis/../../node_modules/lodash/_cloneRegExp.js","webpack://use-logging-apis/../../node_modules/lodash/_cloneSymbol.js","webpack://use-logging-apis/../../node_modules/lodash/_cloneTypedArray.js","webpack://use-logging-apis/../../node_modules/lodash/_copyArray.js","webpack://use-logging-apis/../../node_modules/lodash/_copyObject.js","webpack://use-logging-apis/../../node_modules/lodash/_copySymbols.js","webpack://use-logging-apis/../../node_modules/lodash/_copySymbolsIn.js","webpack://use-logging-apis/../../node_modules/lodash/_coreJsData.js","webpack://use-logging-apis/../../node_modules/lodash/_defineProperty.js","webpack://use-logging-apis/../../node_modules/lodash/_equalArrays.js","webpack://use-logging-apis/../../node_modules/lodash/_equalByTag.js","webpack://use-logging-apis/../../node_modules/lodash/_equalObjects.js","webpack://use-logging-apis/../../node_modules/lodash/_freeGlobal.js","webpack://use-logging-apis/../../node_modules/lodash/_getAllKeys.js","webpack://use-logging-apis/../../node_modules/lodash/_getAllKeysIn.js","webpack://use-logging-apis/../../node_modules/lodash/_getMapData.js","webpack://use-logging-apis/../../node_modules/lodash/_getNative.js","webpack://use-logging-apis/../../node_modules/lodash/_getPrototype.js","webpack://use-logging-apis/../../node_modules/lodash/_getRawTag.js","webpack://use-logging-apis/../../node_modules/lodash/_getSymbols.js","webpack://use-logging-apis/../../node_modules/lodash/_getSymbolsIn.js","webpack://use-logging-apis/../../node_modules/lodash/_getTag.js","webpack://use-logging-apis/../../node_modules/lodash/_getValue.js","webpack://use-logging-apis/../../node_modules/lodash/_hashClear.js","webpack://use-logging-apis/../../node_modules/lodash/_hashDelete.js","webpack://use-logging-apis/../../node_modules/lodash/_hashGet.js","webpack://use-logging-apis/../../node_modules/lodash/_hashHas.js","webpack://use-logging-apis/../../node_modules/lodash/_hashSet.js","webpack://use-logging-apis/../../node_modules/lodash/_initCloneArray.js","webpack://use-logging-apis/../../node_modules/lodash/_initCloneByTag.js","webpack://use-logging-apis/../../node_modules/lodash/_initCloneObject.js","webpack://use-logging-apis/../../node_modules/lodash/_isIndex.js","webpack://use-logging-apis/../../node_modules/lodash/_isKeyable.js","webpack://use-logging-apis/../../node_modules/lodash/_isMasked.js","webpack://use-logging-apis/../../node_modules/lodash/_isPrototype.js","webpack://use-logging-apis/../../node_modules/lodash/_listCacheClear.js","webpack://use-logging-apis/../../node_modules/lodash/_listCacheDelete.js","webpack://use-logging-apis/../../node_modules/lodash/_listCacheGet.js","webpack://use-logging-apis/../../node_modules/lodash/_listCacheHas.js","webpack://use-logging-apis/../../node_modules/lodash/_listCacheSet.js","webpack://use-logging-apis/../../node_modules/lodash/_mapCacheClear.js","webpack://use-logging-apis/../../node_modules/lodash/_mapCacheDelete.js","webpack://use-logging-apis/../../node_modules/lodash/_mapCacheGet.js","webpack://use-logging-apis/../../node_modules/lodash/_mapCacheHas.js","webpack://use-logging-apis/../../node_modules/lodash/_mapCacheSet.js","webpack://use-logging-apis/../../node_modules/lodash/_mapToArray.js","webpack://use-logging-apis/../../node_modules/lodash/_nativeCreate.js","webpack://use-logging-apis/../../node_modules/lodash/_nativeKeys.js","webpack://use-logging-apis/../../node_modules/lodash/_nativeKeysIn.js","webpack://use-logging-apis/../../node_modules/lodash/_nodeUtil.js","webpack://use-logging-apis/../../node_modules/lodash/_objectToString.js","webpack://use-logging-apis/../../node_modules/lodash/_overArg.js","webpack://use-logging-apis/../../node_modules/lodash/_root.js","webpack://use-logging-apis/../../node_modules/lodash/_setCacheAdd.js","webpack://use-logging-apis/../../node_modules/lodash/_setCacheHas.js","webpack://use-logging-apis/../../node_modules/lodash/_setToArray.js","webpack://use-logging-apis/../../node_modules/lodash/_stackClear.js","webpack://use-logging-apis/../../node_modules/lodash/_stackDelete.js","webpack://use-logging-apis/../../node_modules/lodash/_stackGet.js","webpack://use-logging-apis/../../node_modules/lodash/_stackHas.js","webpack://use-logging-apis/../../node_modules/lodash/_stackSet.js","webpack://use-logging-apis/../../node_modules/lodash/_toSource.js","webpack://use-logging-apis/../../node_modules/lodash/cloneDeep.js","webpack://use-logging-apis/../../node_modules/lodash/eq.js","webpack://use-logging-apis/../../node_modules/lodash/isArguments.js","webpack://use-logging-apis/../../node_modules/lodash/isArray.js","webpack://use-logging-apis/../../node_modules/lodash/isArrayLike.js","webpack://use-logging-apis/../../node_modules/lodash/isBuffer.js","webpack://use-logging-apis/../../node_modules/lodash/isEqual.js","webpack://use-logging-apis/../../node_modules/lodash/isFunction.js","webpack://use-logging-apis/../../node_modules/lodash/isLength.js","webpack://use-logging-apis/../../node_modules/lodash/isMap.js","webpack://use-logging-apis/../../node_modules/lodash/isObject.js","webpack://use-logging-apis/../../node_modules/lodash/isObjectLike.js","webpack://use-logging-apis/../../node_modules/lodash/isSet.js","webpack://use-logging-apis/../../node_modules/lodash/isTypedArray.js","webpack://use-logging-apis/../../node_modules/lodash/keys.js","webpack://use-logging-apis/../../node_modules/lodash/keysIn.js","webpack://use-logging-apis/../../node_modules/lodash/stubArray.js","webpack://use-logging-apis/../../node_modules/lodash/stubFalse.js","webpack://use-logging-apis/webpack/bootstrap","webpack://use-logging-apis/webpack/runtime/global","webpack://use-logging-apis/webpack/runtime/make namespace object","webpack://use-logging-apis/webpack/runtime/node module decorator","webpack://use-logging-apis/./client/src/app.ts"],"sourcesContent":["'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar require$$0 = require('events');\nvar require$$0$1 = require('lodash/cloneDeep');\nvar require$$3 = require('lodash/isEqual');\n\nfunction _mergeNamespaces(n, m) {\n\tm.forEach(function (e) {\n\t\te && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {\n\t\t\tif (k !== 'default' && !(k in n)) {\n\t\t\t\tvar d = Object.getOwnPropertyDescriptor(e, k);\n\t\t\t\tObject.defineProperty(n, k, d.get ? d : {\n\t\t\t\t\tenumerable: true,\n\t\t\t\t\tget: function () { return e[k]; }\n\t\t\t\t});\n\t\t\t}\n\t\t});\n\t});\n\treturn Object.freeze(n);\n}\n\nvar commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};\n\nfunction getDefaultExportFromCjs (x) {\n\treturn x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;\n}\n\nvar OpenFin$2 = {};\n\nvar events = {};\n\nvar application$1 = {};\n\n/**\n * Namespace for events that can be emitted by an {@link OpenFin.Application}.  Includes events\n * re-propagated from the {@link OpenFin.Window} (and, transitively, {@link OpenFin.View}) level, prefixed with `window-` (and also, if applicable, `view-`).\n * For example, a view's \"attached\" event will fire as 'window-view-attached' at the application level.\n *\n * Event payloads are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.\n * Events gain metadata as they propagate, which is *not* present on the explicit payload interfaces.  To refer to the full type\n * of an event as it would be raised on this emitter, use {@link Payload}.\n *\n * This namespace contains only payload shapes for events that are unique to `Application`.  Events that propagate to `Application` from\n * child {@link OpenFin.Window windows} and {@link OpenFin.View views} are defined in the {@link OpenFin.WindowEvents} and\n * {@link OpenFin.ViewEvents} namespaces.  For a list of valid string keys for *all* application events, see {@link Application.on Application.on}.\n *\n * {@link ApplicationSourcedEvent Application-sourced events} (i.e. those that have not propagated from {@link OpenFin.ViewEvents Views}\n * or {@link OpenFin.WindowEvents Windows} re-propagate to {@link OpenFin.SystemEvents System} with their type string prefixed with `application-`.\n * {@link ApplicationWindowEvent Application events that are tied to Windows but do not propagate from them}\n * are propagated to `System` without any type string prefixing.\n *\n * \"Requested\" events (e.g. {@link RunRequestedEvent}) do not propagate.\n *\n * @packageDocumentation\n */\nObject.defineProperty(application$1, \"__esModule\", { value: true });\n\nvar base$1 = {};\n\n/**\n * Namespace for shared event payloads and utility types common to all event emitters.\n *\n * @packageDocumentation\n */\nObject.defineProperty(base$1, \"__esModule\", { value: true });\n\nvar externalApplication$1 = {};\n\n/**\n * Namespace for events that can be transmitted by an {@link OpenFin.ExternalApplication}.\n *\n * Event payloads are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.\n * Events gain metadata as they propagate, which is *not* present on the explicit payload interfaces.  To refer to the full type\n * of an event as it would be raised on this emitter, use {@link Payload}.\n *\n * For a list of valid string keys for external application events, see {@link ExternalApplication.on ExternalApplication.on}.\n *\n * @packageDocumentation\n */\nObject.defineProperty(externalApplication$1, \"__esModule\", { value: true });\n\nvar frame$1 = {};\n\nObject.defineProperty(frame$1, \"__esModule\", { value: true });\n\nvar globalHotkey$1 = {};\n\n/**\n *\n * Namespace for events that can be transmitted by {@link GlobalHotkey.GlobalHotkey}.\n *\n * Event payloads are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.\n * Events gain metadata as they propagate, which is *not* present on the explicit payload interfaces.  To refer to the full type\n * of an event as it would be raised on this emitter, use {@link Payload}.\n *\n * For a list of valid string keys for global hotkey events, see {@link GlobalHotkey.GlobalHotkey.on GlobalHotkey.on}.\n *\n * @packageDocumentation\n */\nObject.defineProperty(globalHotkey$1, \"__esModule\", { value: true });\n\nvar platform$1 = {};\n\n/**\n *\n * Namespace for events that can emitted by a {@link OpenFin.Platform}.\n *\n * Event payloads are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.\n * Events gain metadata as they propagate, which is *not* present on the explicit payload interfaces.  To refer to the full type\n * of an event as it would be raised on this emitter, use {@link Payload}.\n *\n * The Platform `EventEmitter` is a superset of the {@link OpenFin.Application} `EventEmitter`,\n * meaning it can listen to all {@link OpenFin.ApplicationEvents Application events} in addition to the\n * Platform-specific events listed here.  For a list of valid string keys for *all* platform events, see\n * {@link Platform.on Platform.on}.\n *\n * @packageDocumentation\n */\nObject.defineProperty(platform$1, \"__esModule\", { value: true });\n\nvar system$1 = {};\n\n/**\n * Namespace for runtime-wide OpenFin events emitted by {@link System.System}.  Includes events\n * re-propagated from {@link OpenFin.Application}, {@link OpenFin.Window}, and {@link OpenFin.View} (prefixed with `application-`, `window-`, and `view-`).  All\n * event propagations are visible at the System level. Propagated events from WebContents (windows, views, frames) to the Application level will *not*\n * transitively re-propagate to the System level, because they are already visible at the system level and contain the identity\n * of the application.  For example, an application's \"closed\" event will fire as 'application-closed' at the system level.  A view's 'shown' event\n * will be visible as 'view-shown' at the system level, but *not* as `application-window-view-shown`.\n *\n * Event payloads are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.\n * Events gain metadata as they propagate, which is *not* present on the explicit payload interfaces.  To refer to the full type\n * of an event as it would be raised on this emitter, use {@link Payload}.\n *\n * This namespace contains only payload shapes for events that are unique to `System`.  Events that propagate to `System` from\n * child {@link OpenFin.Application applications}, {@link OpenFin.Window windows}, and {@link OpenFin.View views} are defined in the\n * {@link OpenFin.ApplicationEvents}, {@link OpenFin.WindowEvents}, and {@link OpenFin.ViewEvents} namespaces.  For a list of valid string keys for *all*\n * system events, see {@link System.on System.on}.\n *\n * @packageDocumentation\n */\nObject.defineProperty(system$1, \"__esModule\", { value: true });\n\nvar view$1 = {};\n\n/**\n * Namespace for events that can be emitted by a {@link OpenFin.View}.\n *\n * Event payloads are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.\n * Events gain metadata as they propagate, which is *not* present on the explicit payload interfaces.  To refer to the full type\n * of an event as it would be raised on this emitter, use {@link Payload}.\n *\n * This namespace contains only payload shapes for events that are unique to `View`.  Events that are shared between all `WebContents`\n * (i.e. {@link OpenFin.Window}, {@link OpenFin.View}) are defined in {@link OpenFin.WebContentsEvents}.  For a list\n * of valid string keys for *all* View events, see {@link View.on View.on}.\n *\n * View events propagate to their parent {@link OpenFin.WindowEvents Window}, {@link OpenFin.ApplicationEvents Application},\n * and {@link OpenFin.SystemEvents System} with an added `viewIdentity` property and their event types prefixed with `'view-'`.\n *\n * @packageDocumentation\n */\nObject.defineProperty(view$1, \"__esModule\", { value: true });\n\nvar webcontents = {};\n\n/**\n * Namespace for events shared by all OpenFin WebContents elements (i.e. {@link OpenFin.Window},\n * {@link OpenFin.View}).\n *\n * WebContents events will re-emit on parent entities - e.g., a propagating event in a view will also be emitted on the view's\n * parent window, and propagating events in a window will also be emitted on the window's parent {@link OpenFin.Application}.\n *\n * @packageDocumentation\n */\nObject.defineProperty(webcontents, \"__esModule\", { value: true });\n\nvar window$2 = {};\n\n/**\n * Namespace for events that can be emitted by a {@link OpenFin.Window}.\n *\n * Event payloads are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.\n * Events gain metadata as they propagate, which is *not* present on the explicit payload interfaces.  To refer to the full type\n * of an event as it would be raised on this emitter, use {@link Payload}.\n *\n * This namespace contains only payload shapes for events that are unique to `Window`.  Events that are shared between all `WebContents`\n * (i.e. {@link OpenFin.Window}, {@link OpenFin.View}) are defined in {@link OpenFin.WebContentsEvents}. Events that\n * propagate from `View` are defined in {@link OpenFin.ViewEvents}. For a list of valid string keys for *all* Window events, see\n * {@link Window.on Window.on}\n *\n * {@link OpenFin.WindowEvents.WindowSourcedEvent Window-sourced events} (i.e. those that are not propagated from a\n * {@link OpenFin.ViewEvents View}) propagate to their parent {@link OpenFin.ApplicationEvents Application} and\n * {@link OpenFin.SystemEvents System} with their event types prefixed with `'window-'`).\n *\n * \"Requested\" events (e.g. {@link AuthRequestedEvent}) do not propagate to `System.  The {@link OpenFin.WindowEvents.WindowCloseRequestedEvent}\n * does not propagate at all.\n *\n * @packageDocumentation\n */\nObject.defineProperty(window$2, \"__esModule\", { value: true });\n\n/**\n * Namespace for OpenFin event types. Each entity that emits OpenFin events has its own sub-namespace. Event payloads\n * themselves are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.\n *\n * #### Event emitters\n *\n * The following entities emit OpenFin events, and have corresponding sub-namespaces:\n *\n * * {@link OpenFin.Application}: {@link OpenFin.ApplicationEvents}\n * * {@link OpenFin.ExternalApplication}: {@link OpenFin.ExternalApplicationEvents}\n * * {@link OpenFin.Frame}: {@link OpenFin.FrameEvents}\n * * {@link OpenFin.GlobalHotkey}: {@link OpenFin.GlobalHotkeyEvents}\n * * {@link OpenFin.Platform}: {@link OpenFin.PlatformEvents}\n * * {@link OpenFin.System}: {@link OpenFin.SystemEvents}\n * * {@link OpenFin.View}: {@link OpenFin.ViewEvents}\n * * {@link OpenFin.Window}: {@link OpenFin.WindowEvents}\n *\n * These `EventEmitter` entities share a common set of methods for interacting with the OpenFin event bus, which can be\n * seen on the individual documentation pages for each entity type.\n *\n * Registering event handlers is an asynchronous operation. It is important to ensure that the returned Promises are awaited to reduce the\n * risk of race conditions.\n *\n * When the `EventEmitter` receives an event from the browser process and emits on the renderer, all of the functions attached to that\n * specific event are called synchronously. Any values returned by the called listeners are ignored and will be discarded.  If the window document\n * is destroyed by page navigation or reload, its registered event listeners will be removed.\n *\n * We recommend using Arrow Functions for event listeners to ensure the this scope is consistent with the original function context.\n *\n * Events re-propagate from smaller/more-local scopes to larger/more-global scopes.  For example, an event emitted on a specific\n * view will propagate to the window in which the view is embedded, and then to the application in which the window is running, and\n * finally to the OpenFin runtime itself at the \"system\" level.  For details on propagation semantics, see the namespace for\n * the propagating (or propagated-to) entity.\n *\n * If you need the payload type for a specific type of event (especially propagated events), use the emitting topic's `Payload` generic\n * (e.g. {@link WindowEvents.Payload}) with the event's `type` string.  For example, the payload of\n * a {@link ViewEvents.CreatedEvent} after it has propagated to its parent {@link WindowEvents Window} can be found with\n * `WindowEvents.Payload<'view-created'>`.\n *\n * @packageDocumentation\n */\nvar __createBinding$1 = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault$1 = (commonjsGlobal && commonjsGlobal.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar$1 = (commonjsGlobal && commonjsGlobal.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding$1(result, mod, k);\n    __setModuleDefault$1(result, mod);\n    return result;\n};\nObject.defineProperty(events, \"__esModule\", { value: true });\nevents.WindowEvents = events.WebContentsEvents = events.ViewEvents = events.SystemEvents = events.PlatformEvents = events.GlobalHotkeyEvents = events.FrameEvents = events.ExternalApplicationEvents = events.BaseEvents = events.ApplicationEvents = void 0;\nconst ApplicationEvents = __importStar$1(application$1);\nevents.ApplicationEvents = ApplicationEvents;\nconst BaseEvents = __importStar$1(base$1);\nevents.BaseEvents = BaseEvents;\nconst ExternalApplicationEvents = __importStar$1(externalApplication$1);\nevents.ExternalApplicationEvents = ExternalApplicationEvents;\nconst FrameEvents = __importStar$1(frame$1);\nevents.FrameEvents = FrameEvents;\nconst GlobalHotkeyEvents = __importStar$1(globalHotkey$1);\nevents.GlobalHotkeyEvents = GlobalHotkeyEvents;\nconst PlatformEvents = __importStar$1(platform$1);\nevents.PlatformEvents = PlatformEvents;\nconst SystemEvents = __importStar$1(system$1);\nevents.SystemEvents = SystemEvents;\nconst ViewEvents = __importStar$1(view$1);\nevents.ViewEvents = ViewEvents;\nconst WebContentsEvents = __importStar$1(webcontents);\nevents.WebContentsEvents = WebContentsEvents;\nconst WindowEvents = __importStar$1(window$2);\nevents.WindowEvents = WindowEvents;\n\n(function (exports) {\n\t/**\n\t * Top-level namespace for types referenced by the OpenFin API.  Contains:\n\t *\n\t * * The type of the global `fin` entry point ({@link FinApi})\n\t * * Classes that act as static namespaces returned from the `fin` global (e.g. {@link ApplicationModule}, accessible via `fin.Application`)\n\t * * Instance classes that are returned from API calls (e.g. {@link Application}, accessible via `fin.Application.getCurrentSync()`)\n\t * * Parameter shapes for API methods (e.g. {@link ApplicationOptions}, used in `fin.Application.start()`)\n\t * * Event namespaces and payload union types (e.g. {@link ApplicationEvents} and {@link ApplicationEvent})\n\t *\n\t * @packageDocumentation\n\t */\n\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t    }\n\t    Object.defineProperty(o, k2, desc);\n\t}) : (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    o[k2] = m[k];\n\t}));\n\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t};\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t// Deprecated shim to preserve v30 namespace names\n\t__exportStar(events, exports); \n} (OpenFin$2));\n\nvar OpenFin = /*@__PURE__*/getDefaultExportFromCjs(OpenFin$2);\n\nvar OpenFin$1 = /*#__PURE__*/_mergeNamespaces({\n\t__proto__: null,\n\tdefault: OpenFin\n}, [OpenFin$2]);\n\nvar fin$2 = {};\n\nvar system = {};\n\nvar base = {};\n\nvar promises = {};\n\nObject.defineProperty(promises, \"__esModule\", { value: true });\npromises.promiseMapSerial = promises.serial = promises.promiseMap = promises.promisify = void 0;\nfunction promisify(func) {\n    return (...args) => new Promise((resolve, reject) => {\n        func(...args, (err, val) => (err ? reject(err) : resolve(val)));\n    });\n}\npromises.promisify = promisify;\nasync function promiseMap(arr, asyncF) {\n    return Promise.all(arr.map(asyncF));\n}\npromises.promiseMap = promiseMap;\nasync function serial(arr) {\n    const ret = [];\n    for (const func of arr) {\n        // eslint-disable-next-line no-await-in-loop\n        const next = await func();\n        ret.push(next);\n    }\n    return ret;\n}\npromises.serial = serial;\nasync function promiseMapSerial(arr, func) {\n    return serial(arr.map((value, index, array) => () => func(value, index, array)));\n}\npromises.promiseMapSerial = promiseMapSerial;\n\nvar __classPrivateFieldSet$c = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar __classPrivateFieldGet$e = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar _EmitterBase_emitterAccessor;\nObject.defineProperty(base, \"__esModule\", { value: true });\nbase.Reply = base.EmitterBase = base.Base = void 0;\nconst promises_1 = promises;\nclass Base {\n    /**\n     * @internal\n     */\n    constructor(wire) {\n        /**\n         * @internal\n         * @deprecated\n         */\n        this.isNodeEnvironment = () => {\n            return this.wire.environment.type === 'node';\n        };\n        /**\n         * @internal\n         * @deprecated\n         */\n        this.isOpenFinEnvironment = () => {\n            return this.wire.environment.type === 'openfin';\n        };\n        /**\n         * @internal\n         * @deprecated\n         */\n        this.isBrowserEnvironment = () => {\n            return this.wire.environment.type === 'other';\n        };\n        this.wire = wire;\n    }\n    get fin() {\n        return this.wire.getFin();\n    }\n    /**\n     * Provides access to the OpenFin representation of the current code context (usually a document\n     * such as a {@link OpenFin.View} or {@link OpenFin.Window}), as well as to the current `Interop` context.\n     *\n     * Useful for debugging in the devtools console, where this will intelligently type itself based\n     * on the context in which the devtools panel was opened.\n     */\n    get me() {\n        return this.wire.me;\n    }\n}\nbase.Base = Base;\n/**\n * An entity that emits OpenFin events.\n *\n * @remarks Event-binding methods are asynchronous as they must cross process boundaries\n * and setup the listener in the browser process.  When the `EventEmitter` receives an event from the browser process\n * and emits on the renderer, all of the functions attached to that specific event are called synchronously.  Any values\n * returned by the called listeners are ignored and will be discarded.  If the execution context of the window is destroyed\n * by page navigation or reload, any events that have been setup in that context will be destroyed.\n *\n * It is important to keep in mind that when an ordinary listener function is called, the standard `this` keyword is intentionally\n * set to reference the `EventEmitter` instance to which the listener is attached.  It is possible to use ES6 Arrow Functions as\n * listeners, however, when doing so, the `this` keyword will no longer reference the `EventEmitter` instance.\n *\n * Events re-propagate from smaller/more-local scopes to larger/more-global scopes.  For example, an event emitted on a specific\n * view will propagate to the window in which the view is embedded, and then to the application in which the window is running, and\n * finally to the OpenFin runtime itself at the \"system\" level.  Re-propagated events are prefixed with the name of the scope in which\n * they originated - for example, a \"shown\" event emitted on a view will be re-propagated at the window level as \"view-shown\", and\n * then to the application as \"window-view-shown\", and finally at the system level as \"application-window-view-shown\".\n *\n * All event propagations are visible at the System level, regardless of source, so transitive re-propagations (e.g. from view to window\n * to application) are visible in their entirety at the system level.  So, we can listen to the above event as \"shown\", \"view-shown\",\n * \"window-view-shown\", or \"application-window-view-shown.\"\n */\nclass EmitterBase extends Base {\n    constructor(wire, topic, ...additionalAccessors) {\n        super(wire);\n        this.topic = topic;\n        _EmitterBase_emitterAccessor.set(this, void 0);\n        this.eventNames = () => (this.hasEmitter() ? this.getOrCreateEmitter().eventNames() : []);\n        /**\n         * @internal\n         */\n        this.emit = (eventType, payload, ...args) => {\n            return this.hasEmitter() ? this.getOrCreateEmitter().emit(eventType, payload, ...args) : false;\n        };\n        this.hasEmitter = () => this.wire.eventAggregator.has(__classPrivateFieldGet$e(this, _EmitterBase_emitterAccessor, \"f\"));\n        this.getOrCreateEmitter = () => this.wire.eventAggregator.getOrCreate(__classPrivateFieldGet$e(this, _EmitterBase_emitterAccessor, \"f\"));\n        this.listeners = (type) => this.hasEmitter() ? this.getOrCreateEmitter().listeners(type) : [];\n        this.listenerCount = (type) => this.hasEmitter() ? this.getOrCreateEmitter().listenerCount(type) : 0;\n        this.registerEventListener = async (eventType, options = {}, applySubscription, undoSubscription) => {\n            const runtimeEvent = {\n                ...this.identity,\n                timestamp: options.timestamp || Date.now(),\n                topic: this.topic,\n                type: eventType\n            };\n            const emitter = this.getOrCreateEmitter();\n            // We apply the subscription and then undo if the async call fails to avoid\n            // indeterminacy in subscription application order, which can break things elsewhere\n            applySubscription(emitter);\n            try {\n                await this.wire.sendAction('subscribe-to-desktop-event', runtimeEvent);\n            }\n            catch (e) {\n                undoSubscription(emitter);\n                this.deleteEmitterIfNothingRegistered(emitter);\n                throw e;\n            }\n        };\n        this.deregisterEventListener = async (eventType, options = {}) => {\n            if (this.hasEmitter()) {\n                const runtimeEvent = {\n                    ...this.identity,\n                    timestamp: options.timestamp || Date.now(),\n                    topic: this.topic,\n                    type: eventType\n                };\n                await this.wire.sendAction('unsubscribe-to-desktop-event', runtimeEvent).catch(() => null);\n                const emitter = this.getOrCreateEmitter();\n                return emitter;\n            }\n            // This will only be reached if unsubscribe from event that does not exist but do not want to error here\n            return Promise.resolve();\n        };\n        __classPrivateFieldSet$c(this, _EmitterBase_emitterAccessor, [topic, ...additionalAccessors], \"f\");\n        this.listeners = (event) => this.hasEmitter() ? this.getOrCreateEmitter().listeners(event) : [];\n    }\n    /**\n     * Adds a listener to the end of the listeners array for the specified event.\n     *\n     * @remarks Event payloads are documented in the {@link OpenFin.Events} namespace.\n     */\n    async on(eventType, listener, options) {\n        await this.registerEventListener(eventType, options, (emitter) => {\n            emitter.on(eventType, listener);\n        }, (emitter) => {\n            emitter.removeListener(eventType, listener);\n        });\n        return this;\n    }\n    /**\n     * Adds a listener to the end of the listeners array for the specified event.\n     */\n    async addListener(eventType, listener, options) {\n        return this.on(eventType, listener, options);\n    }\n    /**\n     * Adds a one time listener for the event. The listener is invoked only the first time the event is fired, after which it is removed.\n     *\n     * @remarks Event payloads are documented in the {@link OpenFin.Events} namespace.\n     */\n    async once(eventType, listener, options) {\n        const deregister = () => this.deregisterEventListener(eventType);\n        await this.registerEventListener(eventType, options, (emitter) => {\n            emitter.once(eventType, deregister);\n            emitter.once(eventType, listener);\n        }, (emitter) => {\n            emitter.removeListener(eventType, deregister);\n            emitter.removeListener(eventType, listener);\n        });\n        return this;\n    }\n    /**\n     * Adds a listener to the beginning of the listeners array for the specified event.\n     *\n     * @remarks Event payloads are documented in the {@link OpenFin.Events} namespace.\n     */\n    async prependListener(eventType, listener, options) {\n        await this.registerEventListener(eventType, options, (emitter) => {\n            emitter.prependListener(eventType, listener);\n        }, (emitter) => {\n            emitter.removeListener(eventType, listener);\n        });\n        return this;\n    }\n    /**\n     * Adds a one time listener for the event. The listener is invoked only the first time the event is fired,\n     * after which it is removed. The listener is added to the beginning of the listeners array.\n     *\n     * @remarks Event payloads are documented in the {@link OpenFin.Events} namespace.\n     */\n    async prependOnceListener(eventType, listener, options) {\n        const deregister = () => this.deregisterEventListener(eventType);\n        await this.registerEventListener(eventType, options, (emitter) => {\n            emitter.prependOnceListener(eventType, listener);\n            emitter.once(eventType, deregister);\n        }, (emitter) => {\n            emitter.removeListener(eventType, listener);\n            emitter.removeListener(eventType, deregister);\n        });\n        return this;\n    }\n    /**\n     * Remove a listener from the listener array for the specified event.\n     *\n     * @remarks Caution: Calling this method changes the array indices in the listener array behind the listener.\n     */\n    async removeListener(eventType, listener, options) {\n        const emitter = await this.deregisterEventListener(eventType, options);\n        if (emitter) {\n            emitter.removeListener(eventType, listener);\n            this.deleteEmitterIfNothingRegistered(emitter);\n        }\n        return this;\n    }\n    async deregisterAllListeners(eventType) {\n        const runtimeEvent = { ...this.identity, type: eventType, topic: this.topic };\n        if (this.hasEmitter()) {\n            const emitter = this.getOrCreateEmitter();\n            const refCount = emitter.listenerCount(runtimeEvent.type);\n            const unsubscribePromises = [];\n            for (let i = 0; i < refCount; i++) {\n                unsubscribePromises.push(this.wire.sendAction('unsubscribe-to-desktop-event', runtimeEvent).catch(() => null));\n            }\n            await Promise.all(unsubscribePromises);\n            return emitter;\n        }\n        return undefined;\n    }\n    /**\n     * Removes all listeners, or those of the specified event.\n     *\n     */\n    async removeAllListeners(eventType) {\n        const removeByEvent = async (event) => {\n            const emitter = await this.deregisterAllListeners(event);\n            if (emitter) {\n                emitter.removeAllListeners(event);\n                this.deleteEmitterIfNothingRegistered(emitter);\n            }\n        };\n        if (eventType) {\n            await removeByEvent(eventType);\n        }\n        else if (this.hasEmitter()) {\n            const events = this.getOrCreateEmitter().eventNames();\n            await (0, promises_1.promiseMap)(events, removeByEvent);\n        }\n        return this;\n    }\n    deleteEmitterIfNothingRegistered(emitter) {\n        if (emitter.eventNames().length === 0) {\n            this.wire.eventAggregator.delete(__classPrivateFieldGet$e(this, _EmitterBase_emitterAccessor, \"f\"));\n        }\n    }\n}\nbase.EmitterBase = EmitterBase;\n_EmitterBase_emitterAccessor = new WeakMap();\nclass Reply {\n}\nbase.Reply = Reply;\n\nvar transportErrors = {};\n\nObject.defineProperty(transportErrors, \"__esModule\", { value: true });\ntransportErrors.RuntimeError = transportErrors.NotSupportedError = transportErrors.NotImplementedError = transportErrors.NoAckError = transportErrors.DuplicateCorrelationError = transportErrors.UnexpectedActionError = transportErrors.DisconnectedError = void 0;\nclass DisconnectedError extends Error {\n    constructor(readyState) {\n        super(`Expected websocket state OPEN but found ${readyState}`);\n        this.readyState = readyState;\n    }\n}\ntransportErrors.DisconnectedError = DisconnectedError;\nclass UnexpectedActionError extends Error {\n}\ntransportErrors.UnexpectedActionError = UnexpectedActionError;\nclass DuplicateCorrelationError extends Error {\n}\ntransportErrors.DuplicateCorrelationError = DuplicateCorrelationError;\nclass NoAckError extends Error {\n}\ntransportErrors.NoAckError = NoAckError;\nclass NotImplementedError extends Error {\n}\ntransportErrors.NotImplementedError = NotImplementedError;\nclass NotSupportedError extends Error {\n}\ntransportErrors.NotSupportedError = NotSupportedError;\nclass InternalError extends Error {\n    constructor(err) {\n        const { message, name, stack, ...rest } = err;\n        super(message);\n        this.name = name || 'Error';\n        this.stack = stack ?? this.toString();\n        Object.keys(rest).forEach(key => {\n            this[key] = rest[key];\n        });\n    }\n}\n// For documentation of the error methods being used see here: https://v8.dev/docs/stack-trace-api\nclass RuntimeError extends Error {\n    static getCallSite(callsToRemove = 0) {\n        const length = Error.stackTraceLimit;\n        const realCallsToRemove = callsToRemove + 1; // remove this call;\n        Error.stackTraceLimit = length + realCallsToRemove;\n        // eslint-disable-next-line no-underscore-dangle\n        const _prepareStackTrace = Error.prepareStackTrace;\n        // This will be called when we access the `stack` property\n        Error.prepareStackTrace = (_, stack) => stack;\n        // stack is optional in non chromium contexts\n        const stack = new Error().stack?.slice(realCallsToRemove) ?? [];\n        Error.prepareStackTrace = _prepareStackTrace;\n        Error.stackTraceLimit = length;\n        return stack;\n    }\n    static prepareStackTrace(err, callSites) {\n        if (typeof Error.prepareStackTrace === 'function') {\n            return Error.prepareStackTrace(err, callSites);\n        }\n        let string = \"\";\n        string += err.name || \"Error\";\n        string += `: ${err.message || \"\"}`;\n        for (const callSite of callSites) {\n            string += `\\n    at ${callSite.toString()}`;\n        }\n        return string;\n    }\n    ;\n    constructor(payload, callSites) {\n        const { reason, error } = payload;\n        super(reason);\n        this.name = 'RuntimeError';\n        if (error?.stack) {\n            this.cause = new InternalError(error);\n        }\n        if (callSites) {\n            this.stack = RuntimeError.prepareStackTrace(this, callSites);\n        }\n    }\n}\ntransportErrors.RuntimeError = RuntimeError;\n\nvar window$1 = {};\n\nvar Factory$8 = {};\n\nvar validate = {};\n\nObject.defineProperty(validate, \"__esModule\", { value: true });\nvalidate.validateIdentity = void 0;\nfunction validateIdentity(identity) {\n    let errorMsg;\n    if (typeof identity !== 'object' || typeof identity.uuid !== 'string') {\n        errorMsg = 'Not a valid identity object';\n    }\n    return errorMsg;\n}\nvalidate.validateIdentity = validateIdentity;\n\nvar Instance$7 = {};\n\nvar application = {};\n\nvar Factory$7 = {};\n\nvar Instance$6 = {};\n\nvar view = {};\n\nvar Factory$6 = {};\n\nvar warnings = {};\n\nObject.defineProperty(warnings, \"__esModule\", { value: true });\nwarnings.handleDeprecatedWarnings = void 0;\nconst handleDeprecatedWarnings = (options) => {\n    if (options.contentNavigation?.whitelist ||\n        options.contentNavigation?.blacklist ||\n        options.contentRedirect?.whitelist ||\n        options.contentRedirect?.blacklist) {\n        console.warn(`The properties 'whitelist' and 'blacklist' have been marked as deprecated and will be removed in a future version. Please use 'allowlist' and 'denylist'.`);\n    }\n};\nwarnings.handleDeprecatedWarnings = handleDeprecatedWarnings;\n\nvar hasRequiredFactory$3;\n\nfunction requireFactory$3 () {\n\tif (hasRequiredFactory$3) return Factory$6;\n\thasRequiredFactory$3 = 1;\n\tObject.defineProperty(Factory$6, \"__esModule\", { value: true });\n\tFactory$6.ViewModule = void 0;\n\tconst base_1 = base;\n\tconst validate_1 = validate;\n\tconst index_1 = requireView();\n\tconst warnings_1 = warnings;\n\t/**\n\t * Static namespace for OpenFin API methods that interact with the {@link View} class, available under `fin.View`.\n\t */\n\tclass ViewModule extends base_1.Base {\n\t    /**\n\t     * Creates a new View.\n\t     * @param options - View creation options\n\t     *\n\t     * @example\n\t     * ```js\n\t     * let view;\n\t     * async function createView() {\n\t     *     const me = await fin.Window.getCurrent();\n\t     *     return fin.View.create({\n\t     *         name: 'viewNameCreate',\n\t     *         target: me.identity,\n\t     *         bounds: {top: 10, left: 10, width: 200, height: 200}\n\t     *     });\n\t     * }\n\t     *\n\t     * createView()\n\t     *     .then((createdView) => {\n\t     *         view = createdView;\n\t     *         console.log('View created.', view);\n\t     *         view.navigate('https://google.com');\n\t     *         console.log('View navigated to given url.');\n\t     *     })\n\t     *     .catch(err => console.log(err));\n\t     * ```\n\t     * Note that created views needs to navigate somewhere for them to actually render a website.\n\t     * @experimental\n\t     */\n\t    async create(options) {\n\t        const { uuid } = this.wire.me;\n\t        if (!options.name || typeof options.name !== 'string') {\n\t            throw new Error('Please provide a name property as a string in order to create a View.');\n\t        }\n\t        (0, warnings_1.handleDeprecatedWarnings)(options);\n\t        if (this.wire.environment.childViews) {\n\t            await this.wire.environment.createChildContent({\n\t                entityType: 'view',\n\t                options: { ...options, uuid }\n\t            });\n\t        }\n\t        else {\n\t            await this.wire.sendAction('create-view', { ...options, uuid });\n\t        }\n\t        return this.wrapSync({ uuid, name: options.name });\n\t    }\n\t    /**\n\t     * Asynchronously returns an API handle for the given View identity.\n\t     *\n\t     * @remarks Wrapping a View identity that does not yet exist will *not* throw an error, and instead\n\t     * returns a stub object that cannot yet perform rendering tasks. This can be useful for plumbing eventing\n\t     * for a View throughout its entire lifecycle.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.View.wrap({ uuid: 'testViewUuid', name: 'testViewName' }))\n\t     *     .then(view => console.log('wrapped view', view))\n\t     *     .catch(err => console.log(err));\n\t     * ```\n\t     * @experimental\n\t     */\n\t    async wrap(identity) {\n\t        this.wire.sendAction('view-wrap').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const errorMsg = (0, validate_1.validateIdentity)(identity);\n\t        if (errorMsg) {\n\t            throw new Error(errorMsg);\n\t        }\n\t        return new index_1.View(this.wire, identity);\n\t    }\n\t    /**\n\t     * Synchronously returns an API handle for the given View identity.\n\t     *\n\t     * @remarks Wrapping a View identity that does not yet exist will *not* throw an error, and instead\n\t     * returns a stub object that cannot yet perform rendering tasks. This can be useful for plumbing eventing\n\t     * for a View throughout its entire lifecycle.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * const view = fin.View.wrapSync({ uuid: 'testView', name: 'testViewName' });\n\t     * await view.hide();\n\t     * ```\n\t     * @experimental\n\t     */\n\t    wrapSync(identity) {\n\t        this.wire.sendAction('view-wrap-sync').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const errorMsg = (0, validate_1.validateIdentity)(identity);\n\t        if (errorMsg) {\n\t            throw new Error(errorMsg);\n\t        }\n\t        return new index_1.View(this.wire, identity);\n\t    }\n\t    /**\n\t     * Asynchronously returns a View object that represents the current view\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.View.getCurrent()\n\t     *     .then(view => console.log('current view', view))\n\t     *     .catch(err => console.log(err));\n\t     *\n\t     * ```\n\t     * @experimental\n\t     */\n\t    getCurrent() {\n\t        this.wire.sendAction('view-get-current').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        if (!this.wire.me.isView) {\n\t            throw new Error('You are not in a View context');\n\t        }\n\t        const { uuid, name } = this.wire.me;\n\t        return this.wrap({ uuid, name });\n\t    }\n\t    /**\n\t     * Synchronously returns a View object that represents the current view\n\t     *\n\t     * @example\n\t     * ```js\n\t     * const view = fin.View.getCurrentSync();\n\t     * console.log(view);\n\t     *\n\t     * ```\n\t     * @experimental\n\t     */\n\t    getCurrentSync() {\n\t        this.wire.sendAction('view-get-current-sync').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        if (!this.wire.me.isView) {\n\t            throw new Error('You are not in a View context');\n\t        }\n\t        const { uuid, name } = this.wire.me;\n\t        return this.wrapSync({ uuid, name });\n\t    }\n\t}\n\tFactory$6.ViewModule = ViewModule;\n\treturn Factory$6;\n}\n\nvar Instance$5 = {};\n\nvar lazy = {};\n\nObject.defineProperty(lazy, \"__esModule\", { value: true });\nlazy.AsyncRetryableLazy = lazy.Lazy = void 0;\n/**\n * Handy class for managing asynchronous dependencies of classes.\n *\n * Will call the producer function once and only once when getValue is called,\n * returning the resultant value for every subsequent call.\n */\nclass Lazy {\n    // eslint-disable-next-line\n    constructor(producerFn) {\n        this.producerFn = producerFn;\n    }\n    /**\n     * Lazily get the value returned by the producer.\n     * @returns The value returned from the producer function\n     */\n    getValue() {\n        if (!this.value) {\n            this.value = this.producerFn();\n        }\n        return this.value;\n    }\n}\nlazy.Lazy = Lazy;\n/**\n * Handy class for managing asynchronous dependencies of classes.\n *\n * Will call asynchronous producer only after `getValue` is called.  If the\n * deferred code errors, we can try it again by re-calling `getValue` after\n * the promise rejects.\n */\nclass AsyncRetryableLazy {\n    // eslint-disable-next-line\n    constructor(producerFn) {\n        this.producerFn = producerFn;\n    }\n    /**\n     * Lazily get the value returned by the async producer.\n     *\n     * @returns The value returned from the producer function\n     */\n    async getValue() {\n        if (!this.promise) {\n            this.promise = this.producerFn().catch((e) => {\n                delete this.promise;\n                throw e;\n            });\n        }\n        return this.promise;\n    }\n}\nlazy.AsyncRetryableLazy = AsyncRetryableLazy;\n\nvar layoutEntities = {};\n\nvar apiExposer$1 = {};\n\nvar apiConsumer = {};\n\nObject.defineProperty(apiConsumer, \"__esModule\", { value: true });\napiConsumer.ApiConsumer = void 0;\n/**\n * Consumer for apis exposed with {@see ApiExposer}.\n *\n * A strategy that matches the strategy used to expose a target API must be provided.\n */\nclass ApiConsumer {\n    // eslint-disable-next-line\n    constructor(strategy) {\n        this.strategy = strategy;\n        /**\n         * Consumes an api exposed using a given transport strategy, and generates a client\n         * for easy, type safe consumption of that client.\n         * @param options Strategy specific consumption options.\n         * @returns An api client matching the given type.\n         */\n        this.consume = async (options) => {\n            const exposedProperties = await this.strategy.getExposedFunctions(options);\n            return exposedProperties.reduce((client, prop) => ({\n                ...client,\n                [prop.key]: this.strategy.createFunction(prop, options)\n            }), {});\n        };\n    }\n}\napiConsumer.ApiConsumer = ApiConsumer;\n\nvar apiExposer = {};\n\nvar decorators = {};\n\nObject.defineProperty(decorators, \"__esModule\", { value: true });\ndecorators.expose = decorators.getExposedProperties = void 0;\nconst exposedProperties = Symbol('exposedProperties');\nconst getExposedProperties = (target) => {\n    return target[exposedProperties] || target.prototype[exposedProperties] || [];\n};\ndecorators.getExposedProperties = getExposedProperties;\n/**\n * Indicates that a class member function can be exposed using {@link ApiExposer}.\n * @param options Options specific to the strategy used in {@link ApiExposer}\n */\n// Returns any as decorator typing is weird.\nconst expose = (options) => (target, key, descriptor) => {\n    target[exposedProperties] = target[exposedProperties] || [];\n    target[exposedProperties].push({ key, descriptor, options });\n};\ndecorators.expose = expose;\n\nObject.defineProperty(apiExposer, \"__esModule\", { value: true });\napiExposer.ApiExposer = void 0;\nconst decorators_1 = decorators;\n/**\n * Exposes api services on the transport of choice.\n */\nclass ApiExposer {\n    /**\n     * @param strategy The expose strategy to use to expose instances.\n     */\n    // eslint-disable-next-line\n    constructor(strategy) {\n        this.strategy = strategy;\n        /**\n         * Exposes an instance of a given api on\n         * @param instance Instance of a class which has been decorated to indicate which functions can be exposed.\n         * @param instanceOptions Transport strategy specific options to use when exposing.\n         */\n        this.exposeInstance = async (instance, instanceOptions) => {\n            const exposableProps = (0, decorators_1.getExposedProperties)(instance);\n            const exposedProps = await Promise.all(exposableProps.map(async ({ key, options }) => {\n                const customConsumptionOptions = await this.strategy.exposeFunction(instance[key].bind(instance), {\n                    key,\n                    options,\n                    meta: instanceOptions\n                });\n                return {\n                    key,\n                    options: customConsumptionOptions\n                };\n            }));\n            await this.strategy.exposeMeta(instanceOptions, exposedProps);\n        };\n    }\n    ;\n}\napiExposer.ApiExposer = ApiExposer;\n\nvar strategies = {};\n\nvar openfinChannels = {};\n\nvar channelsConsumer = {};\n\nObject.defineProperty(channelsConsumer, \"__esModule\", { value: true });\nchannelsConsumer.ChannelsConsumer = void 0;\nclass ChannelsConsumer {\n    // eslint-disable-next-line\n    constructor(channel) {\n        this.channel = channel;\n        this.getExposedFunctions = async (options) => {\n            const { id } = options;\n            const { props } = await this.channel.dispatch(`api-meta:${id}`);\n            return props;\n        };\n        this.createFunction = (prop) => (...args) => {\n            const { action } = prop.options;\n            return this.channel.dispatch(action, { args });\n        };\n    }\n    ;\n}\nchannelsConsumer.ChannelsConsumer = ChannelsConsumer;\n\nvar channelsExposer = {};\n\nObject.defineProperty(channelsExposer, \"__esModule\", { value: true });\nchannelsExposer.ChannelsExposer = void 0;\nclass ChannelsExposer {\n    // eslint-disable-next-line\n    constructor(channelProviderOrClient) {\n        this.channelProviderOrClient = channelProviderOrClient;\n        this.exposeFunction = async (target, config) => {\n            const { key, options, meta } = config;\n            const { id } = meta;\n            const action = `${id}.${options?.action || key}`;\n            await this.channelProviderOrClient.register(action, async ({ args }) => {\n                return target(...args);\n            });\n            return { action };\n        };\n        this.exposeMeta = async ({ id }, props) => {\n            const action = `api-meta:${id}`;\n            await this.channelProviderOrClient.register(action, () => ({ props }));\n        };\n    }\n}\nchannelsExposer.ChannelsExposer = ChannelsExposer;\n\n(function (exports) {\n\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t    }\n\t    Object.defineProperty(o, k2, desc);\n\t}) : (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    o[k2] = m[k];\n\t}));\n\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t};\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t__exportStar(channelsConsumer, exports);\n\t__exportStar(channelsExposer, exports); \n} (openfinChannels));\n\n(function (exports) {\n\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t    }\n\t    Object.defineProperty(o, k2, desc);\n\t}) : (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    o[k2] = m[k];\n\t}));\n\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t};\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t__exportStar(openfinChannels, exports); \n} (strategies));\n\n(function (exports) {\n\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t    }\n\t    Object.defineProperty(o, k2, desc);\n\t}) : (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    o[k2] = m[k];\n\t}));\n\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t};\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t__exportStar(apiConsumer, exports);\n\t__exportStar(apiExposer, exports);\n\t__exportStar(strategies, exports);\n\t__exportStar(decorators, exports); \n} (apiExposer$1));\n\nvar channelApiRelay = {};\n\nObject.defineProperty(channelApiRelay, \"__esModule\", { value: true });\nchannelApiRelay.createRelayedDispatch = channelApiRelay.relayChannelClientApi = void 0;\nconst EXPECTED_ERRORS = [\n    'no longer connected',\n    'RTCDataChannel closed unexpectedly',\n    'The client you are trying to dispatch from is disconnected from the target provider',\n];\n// Checks possible error messages that we want to trap, client error message can originate\n// from ChannelProvider::dispatch OR ClassicStrategy::closeEndpoint OR RTCEndPoint::dataChannel::onclose\nconst isDisconnectedError = (errorMsg) => {\n    return EXPECTED_ERRORS.some(e => errorMsg.includes(e));\n};\n/**\n * @internal\n * Create a channel relay for a given channel exposition, allowing a single provider to route\n * actions to the designated clients.\n *\n * Designed to be used in conjunction with @expose\n *\n * @param channelProvider The channel provider to relay the actions on.\n * @param config Determines which actions to relay. Please ensure action prefix matches the exposed api.\n */\nconst relayChannelClientApi = async (channelProvider, relayId) => {\n    channelProvider.register(`relay:${relayId}`, ({ action, target, payload }) => {\n        return channelProvider.dispatch(target, action, payload);\n    });\n    await Promise.resolve();\n};\nchannelApiRelay.relayChannelClientApi = relayChannelClientApi;\nconst createRelayedDispatch = (client, target, relayId, relayErrorMsg) => async (action, payload) => {\n    try {\n        return await client.dispatch(`relay:${relayId}`, {\n            action,\n            payload,\n            target\n        });\n    }\n    catch (e) {\n        if (isDisconnectedError(e.message) && relayErrorMsg) {\n            throw new Error(relayErrorMsg);\n        }\n        throw e;\n    }\n};\nchannelApiRelay.createRelayedDispatch = createRelayedDispatch;\n\nvar __classPrivateFieldSet$b = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar __classPrivateFieldGet$d = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar _LayoutNode_client, _TabStack_client, _ColumnOrRow_client;\nObject.defineProperty(layoutEntities, \"__esModule\", { value: true });\nlayoutEntities.ColumnOrRow = layoutEntities.TabStack = layoutEntities.LayoutNode = void 0;\nconst api_exposer_1 = apiExposer$1;\nconst channel_api_relay_1 = channelApiRelay;\n/*\n    This file includes LayoutNode, ColumnOrRow and TabStack classes, which are all closely\n    intertwined, and share members via parent abstract class LayoutNode. To prevent circular\n    refs, we define and export all the classes here.\n*/\n/**\n * @ignore\n * @internal\n * Supplies an ApiClient for {@link LayoutEntitiesController} and helper methods\n * for the entities {@link TabStack} AND {@link ColumnOrRow} to use.\n */\nclass LayoutNode {\n    /**\n     * @internal\n     * @ignore\n     */\n    constructor(client, entityId) {\n        /**\n         * @ignore\n         * @internal\n         * ApiClient for {@link LayoutEntitiesController}\n         */\n        _LayoutNode_client.set(this, void 0);\n        /**\n         * Checks if the TabStack or ColumnOrRow is the root content item\n         *\n         * @example\n         * ```js\n         * if (!fin.me.isView) {\n         *     throw new Error('Not running in a platform View.');\n         * }\n         *\n         * const stack = await fin.me.getCurrentStack();\n         * const isRoot = await stack.isRoot();\n         * // The TabStack is root: false\n         * console.log(`The TabStack is root: ${isRoot}`);\n         *\n         * // Retrieves the parent ColumnOrRow\n         * const parent = await stack.getParent();\n         * const parentIsRoot = await parent.isRoot();\n         * // The parent ColumnOrRow is root: true\n         * console.log(`The parent ColumnOrRow is root: ${parentIsRoot}`);\n         * ```\n         */\n        this.isRoot = () => __classPrivateFieldGet$d(this, _LayoutNode_client, \"f\").isRoot(this.entityId);\n        /**\n         * Checks if the TabStack or ColumnOrRow exists\n         *\n         * @example\n         * ```js\n         * if (!fin.me.isView) {\n         *     throw new Error('Not running in a platform View.');\n         * }\n         *\n         * const stack = await fin.me.getCurrentStack();\n         * // Retrieves the parent ColumnOrRow\n         * const columnOrRow = await stack.getParent();\n         * let exists = await stack.exists();\n         * // or\n         * let exists = await columnOrRow.exists();\n         * // The entity exists: true\n         * console.log(`The entity exists: ${exists}`);\n         * ```\n         */\n        this.exists = () => __classPrivateFieldGet$d(this, _LayoutNode_client, \"f\").exists(this.entityId);\n        /**\n         * Retrieves the parent of the TabStack or ColumnOrRow\n         *\n         * @example\n         * ```js\n         * if (!fin.me.isView) {\n         *     throw new Error('Not running in a platform View.');\n         * }\n         *\n         * const stack = await fin.me.getCurrentStack();\n         * // Retrieves the parent ColumnOrRow\n         * const columnOrRow = await stack.getParent();\n         *\n         * // undefined if entity is the root item\n         * let parent = await columnOrRow.getParent();\n         * // or\n         * let parent = await stack.getParent();\n         * ```\n         */\n        this.getParent = async () => {\n            const parent = await __classPrivateFieldGet$d(this, _LayoutNode_client, \"f\").getParent(this.entityId);\n            if (!parent) {\n                return undefined;\n            }\n            return LayoutNode.getEntity(parent, __classPrivateFieldGet$d(this, _LayoutNode_client, \"f\"));\n        };\n        /**\n         * Creates a new TabStack adjacent to the given TabStack or ColumnOrRow. Inputs can be new views to create, or existing views.\n         *\n         * Known Issue: If the number of views to add overflows the tab-container, the added views will be set as active\n         * during each render, and then placed at the front of the tab-stack, while the underlying order of tabs will remain unchanged.\n         * This means the views you pass to createAdjacentStack() may not render in the order given by the array.\n         * Until fixed, this problem can be avoided only if your window is wide enough to fit creating all the views in the tabstack.\n         *\n         * @param views The views that will populate the new TabStack.\n         * @param options Additional options that control new TabStack creation.\n         * @returns The newly-created TabStack.\n         *\n         * @example\n         * ```js\n         * if (!fin.me.isView) {\n         *     throw new Error('Not running in a platform View.');\n         * }\n         *\n         * const stack = await fin.me.getCurrentStack();\n         * const columnOrRow = await stack.getParent();\n         *\n         * // Create view references by supplying a 'name' and 'url'\n         * const views = [\n         *     // if 'name' is undefined, one will be generated\n         *     // if 'url' is undefined, it will default the view URL to 'about:blank'\n         *     { name: 'google-view', url: 'http://google.com/'},\n         *     { name: 'of-developers-view', url: 'http://developers.openfin.co/'},\n         * ];\n         *\n         * // Create a view beforehand to be included in the new tab stack\n         * const outsideView = await fin.View.create({\n         *     name: 'outside-bloomberg-view',\n         *     url: 'https://bloomberg.com/',\n         *     target: fin.me.identity,\n         * });\n         *\n         * // Views to add can be identities, or the reference views mentioned above\n         * const viewsToAdd = [outsideView.identity, ...views];\n         *\n         * // Possible position inputs: 'right' | 'left' | 'top' | 'bottom'\n         * let stackFrom = await columnOrRow.createAdjacentStack(viewsToAdd, { position: 'right' });\n         * // Or\n         * let newStack = await stack.createAdjacentStack(viewsToAdd, { position: 'right' });\n         * console.log(`A new TabStack created to the right has ${newStack.length} views in it`);\n         *\n         * ```\n         * @experimental\n         */\n        this.createAdjacentStack = async (views, options) => {\n            const entityId = await __classPrivateFieldGet$d(this, _LayoutNode_client, \"f\").createAdjacentStack(this.entityId, views, options);\n            return LayoutNode.getEntity({ entityId, type: 'stack' }, __classPrivateFieldGet$d(this, _LayoutNode_client, \"f\"));\n        };\n        /**\n         * Retrieves the adjacent TabStacks of the given TabStack or ColumnOrRow.\n         *\n         * @param edge Edge whose adjacent TabStacks will be returned.\n         *\n         * @example\n         * ```js\n         * if (!fin.me.isView) {\n         *     throw new Error('Not running in a platform View.');\n         * }\n         *\n         * const stack = await fin.me.getCurrentStack();\n         * const columnOrRow = await stack.getParent();\n         * // Possible position inputs: 'right' | 'left' | 'top' | 'bottom'\n         * let rightStacks = await columnOrRow.getAdjacentStacks('right');\n         * let leftStacks = await columnOrRow.getAdjacentStacks('left');\n         * // or\n         * let rightStacks = await stack.getAdjacentStacks('right');\n         * let leftStacks = await stack.getAdjacentStacks('left');\n         *\n         * console.log(`The entity has ${rightStacks.length} stacks to the right, and ${leftStacks.length} stacks to the left`);\n         *\n         * ```\n         * @experimental\n         */\n        this.getAdjacentStacks = async (edge) => {\n            const adjacentStacks = await __classPrivateFieldGet$d(this, _LayoutNode_client, \"f\").getAdjacentStacks({\n                targetId: this.entityId,\n                edge\n            });\n            return adjacentStacks.map((stack) => LayoutNode.getEntity({\n                type: 'stack',\n                entityId: stack.entityId\n            }, __classPrivateFieldGet$d(this, _LayoutNode_client, \"f\")));\n        };\n        __classPrivateFieldSet$b(this, _LayoutNode_client, client, \"f\");\n        this.entityId = entityId;\n    }\n}\nlayoutEntities.LayoutNode = LayoutNode;\n_LayoutNode_client = new WeakMap();\n/**\n * @ignore\n * @internal\n * Encapsulates Api consumption of {@link LayoutEntitiesClient} with a relayed dispatch\n * @param client\n * @param controllerId\n * @param identity\n * @returns a new instance of {@link LayoutEntitiesClient} with bound to the controllerId\n */\nLayoutNode.newLayoutEntitiesClient = async (client, controllerId, identity) => {\n    const dispatch = (0, channel_api_relay_1.createRelayedDispatch)(client, identity, 'layout-relay', 'You are trying to interact with a layout component on a window that does not exist or has been destroyed.');\n    const consumer = new api_exposer_1.ApiConsumer(new api_exposer_1.ChannelsConsumer({ dispatch }));\n    return consumer.consume({ id: controllerId });\n};\nLayoutNode.getEntity = (definition, client) => {\n    const { entityId, type } = definition;\n    switch (type) {\n        case 'column':\n        case 'row':\n            return new ColumnOrRow(client, entityId, type);\n        case 'stack':\n            return new TabStack(client, entityId);\n        default:\n            throw new Error(`Unrecognised Layout Entity encountered ('${JSON.stringify(definition)})`);\n    }\n};\n/**\n * A TabStack is used to manage the state of a stack of tabs within an OpenFin Layout.\n */\nclass TabStack extends LayoutNode {\n    /** @internal */\n    constructor(client, entityId) {\n        super(client, entityId);\n        /**\n         * @internal\n         * ApiClient for {@link LayoutEntitiesController}\n         */\n        _TabStack_client.set(this, void 0);\n        /**\n         * Type of the content item. Always stack, but useful for distinguishing between a {@link TabStack} and {@link ColumnOrRow}.\n         */\n        this.type = 'stack';\n        /**\n         * Retrieves a list of all views belonging to this {@link TabStack}.\n         *\n         * Known Issue: If adding a view overflows the tab-container width, the added view will be set as active\n         * and rendered at the front of the tab-stack, while the underlying order of tabs will remain unchanged.\n         * If that happens and then getViews() is called, it will return the identities in a different order than\n         * than the currently rendered tab order.\n         *\n         *\n         * @throws If the {@link TabStack} has been destroyed.\n         * @example\n         * ```js\n         * if (!fin.me.isView) {\n         *     throw new Error('Not running in a platform View.');\n         * }\n         *\n         * const stack = await fin.me.getCurrentStack();\n         * // Alternatively, you can wrap any view and get the stack from there\n         * // const viewFromSomewhere = fin.View.wrapSync(someView.identity);\n         * // const stack = await viewFromSomewhere.getCurrentStack();\n         * const views = await stack.getViews();\n         * console.log(`Stack contains ${views.length} view(s)`);\n         * ```\n         * @experimental\n         */\n        this.getViews = () => __classPrivateFieldGet$d(this, _TabStack_client, \"f\").getStackViews(this.entityId);\n        /**\n         * Adds or creates a view in this {@link TabStack}.\n         *\n         * @remarks Known Issue: If adding a view overflows the tab-container, the added view will be set as active\n         * and rendered at the front of the tab-stack, while the underlying order of tabs will remain unchanged.\n         *\n         * @param view The identity of an existing view to add, or options to create a view.\n         * @param options Optional view options: index number used to insert the view into the stack at that index. Defaults to 0 (front of the stack)\n         * @returns Resolves with the {@link OpenFin.Identity identity} of the added view.\n         * @throws If the view does not exist or fails to create.\n         * @throws If the {@link TabStack} has been destroyed.\n         * @example\n         * ```js\n         * if (!fin.me.isView) {\n         *     throw new Error('Not running in a platform View.');\n         * }\n         *\n         * const stack = await fin.me.getCurrentStack();\n         * // Alternatively, you can wrap any view and get the stack from there\n         * // const viewFromSomewhere = fin.View.wrapSync(someView.identity);\n         * // const stack = await viewFromSomewhere.getCurrentStack();\n         * const googleViewIdentity = await stack.addView({ name: 'google-view', url: 'http://google.com/' });\n         * console.log('Identity of the google view just added', { googleViewIdentity });\n         * // pass in { index: number } to set the index in the stack. Here 1 means, end of the stack (defaults to 0)\n         * const appleViewIdentity = await stack.addView({ name: 'apple-view', url: 'http://apple.com/' }, { index: 1 });\n         * console.log('Identity of the apple view just added', { appleViewIdentity });\n         * ```\n         * @experimental\n         */\n        this.addView = async (view, options = { index: 0 }) => __classPrivateFieldGet$d(this, _TabStack_client, \"f\").addViewToStack(this.entityId, view, options);\n        /**\n         * Removes a view from this {@link TabStack}.\n         *\n         * @remarks Throws an exception if the view identity does not exist or was already destroyed.\n         *\n         * @param view - Identity of the view to remove.\n         * @throws If the view does not exist or does not belong to the stack.\n         * @throws If the {@link TabStack} has been destroyed.\n         *\n         * @example\n         * ```js\n         * if (!fin.me.isView) {\n         *     throw new Error('Not running in a platform View.');\n         * }\n         *\n         * const stack = await fin.me.getCurrentStack();\n         * const googleViewIdentity = await stack.addView({ name: 'google-view', url: 'http://google.com/' });\n         *\n         * await stack.removeView(googleViewIdentity);\n         *\n         * try {\n         *     await stack.removeView(googleViewIdentity);\n         * } catch (error) {\n         *     // Tried to remove a view ('google-view') which does not belong to the stack.\n         *     console.log(error);\n         * }\n         * ```\n         */\n        this.removeView = async (view) => {\n            await __classPrivateFieldGet$d(this, _TabStack_client, \"f\").removeViewFromStack(this.entityId, view);\n        };\n        /**\n         * Sets the active view of the {@link TabStack} without focusing it.\n         * @param view - Identity of the view to activate.\n         * @returns Promise which resolves with void once the view has been activated.\n         * @throws If the {@link TabStack} has been destroyed.\n         * @throws If the view does not exist.\n         * @example\n         * Change the active tab of a known View's TabStack:\n         * ```js\n         * const targetView = fin.View.wrapSync({ uuid: 'uuid', name: 'view-name' });\n         * const stack = await targetView.getCurrentStack();\n         * await stack.setActiveView(targetView.identity);\n         * ```\n         *\n         * Set the current View as active within its TabStack:\n         * ```js\n         * const stack = await fin.me.getCurrentStack();\n         * await stack.setActiveView(fin.me.identity);\n         * ```\n         * @experimental\n         */\n        this.setActiveView = async (view) => {\n            await __classPrivateFieldGet$d(this, _TabStack_client, \"f\").setStackActiveView(this.entityId, view);\n        };\n        __classPrivateFieldSet$b(this, _TabStack_client, client, \"f\");\n    }\n}\nlayoutEntities.TabStack = TabStack;\n_TabStack_client = new WeakMap();\n/**\n * A ColumnOrRow is used to manage the state of Column and Rows within an OpenFin Layout.\n */\nclass ColumnOrRow extends LayoutNode {\n    /**\n     * @internal\n     */\n    constructor(client, entityId, type) {\n        super(client, entityId);\n        /**\n         * @ignore\n         * @internal\n         * ApiClient for {@link LayoutEntitiesController}\n         */\n        _ColumnOrRow_client.set(this, void 0);\n        /**\n         * Retrieves the content array of the ColumnOrRow\n         *\n         * @example\n         * ```js\n         * if (!fin.me.isView) {\n         *     throw new Error('Not running in a platform View.');\n         * }\n         *\n         * const stack = await fin.me.getCurrentStack();\n         * // Retrieves the parent ColumnOrRow\n         * const columnOrRow = await stack.getParent();\n         *\n         * // returns [TabStack]\n         * const contentArray = await columnOrRow.getContent();\n         * console.log(`The ColumnOrRow has ${contentArray.length} item(s)`);\n         * ```\n         */\n        this.getContent = async () => {\n            const contentItemEntities = await __classPrivateFieldGet$d(this, _ColumnOrRow_client, \"f\").getContent(this.entityId);\n            return contentItemEntities.map((entity) => LayoutNode.getEntity(entity, __classPrivateFieldGet$d(this, _ColumnOrRow_client, \"f\")));\n        };\n        __classPrivateFieldSet$b(this, _ColumnOrRow_client, client, \"f\");\n        this.type = type;\n    }\n}\nlayoutEntities.ColumnOrRow = ColumnOrRow;\n_ColumnOrRow_client = new WeakMap();\n\nvar layout_constants = {};\n\nObject.defineProperty(layout_constants, \"__esModule\", { value: true });\nlayout_constants.DEFAULT_LAYOUT_KEY = layout_constants.LAYOUT_CONTROLLER_ID = void 0;\nlayout_constants.LAYOUT_CONTROLLER_ID = 'layout-entities';\n// TODO: eventually export this somehow\nlayout_constants.DEFAULT_LAYOUT_KEY = '__default__';\n\nvar main = {};\n\nObject.defineProperty(main, \"__esModule\", { value: true });\nmain.WebContents = void 0;\nconst base_1$j = base;\nclass WebContents extends base_1$j.EmitterBase {\n    /**\n     * @param identity The identity of the {@link OpenFin.WebContentsEvents WebContents}.\n     * @param entityType The type of the {@link OpenFin.WebContentsEvents WebContents}.\n     */\n    constructor(wire, identity, entityType) {\n        super(wire, entityType, identity.uuid, identity.name);\n        this.identity = identity;\n        this.entityType = entityType;\n    }\n    /**\n     * Gets a base64 encoded image of all or part of the WebContents.\n     * @param options Options for the capturePage call.\n     *\n     * @example\n     *\n     * View:\n     * ```js\n     * const view = fin.View.getCurrentSync();\n     *\n     * // PNG image of a full visible View\n     * console.log(await view.capturePage());\n     *\n     * // Low-quality JPEG image of a defined visible area of the view\n     * const options = {\n     *     area: {\n     *         height: 100,\n     *         width: 100,\n     *         x: 10,\n     *         y: 10,\n     *     },\n     *     format: 'jpg',\n     *     quality: 20\n     * }\n     * console.log(await view.capturePage(options));\n     * ```\n     *\n     * Window:\n     * ```js\n     * const wnd = await fin.Window.getCurrent();\n     *\n     * // PNG image of a full visible window\n     * console.log(await wnd.capturePage());\n     *\n     * // Low-quality JPEG image of a defined visible area of the window\n     * const options = {\n     *     area: {\n     *         height: 100,\n     *         width: 100,\n     *         x: 10,\n     *         y: 10,\n     *     },\n     *     format: 'jpg',\n     *     quality: 20\n     * }\n     * console.log(await wnd.capturePage(options));\n     * ```\n     *\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    capturePage(options) {\n        return this.wire.sendAction('capture-page', { options, ...this.identity }).then(({ payload }) => payload.data);\n    }\n    /**\n     * Executes Javascript on the WebContents, restricted to contents you own or contents owned by\n     * applications you have created.\n     * @param code JavaScript code to be executed on the view.\n     *\n     * @example\n     * View:\n     * ```js\n     * async function executeJavaScript(code) {\n     *     const view = await fin.View.wrap({uuid: 'uuid', name: 'view name'});\n     *     return await view.executeJavaScript(code);\n     * }\n     *\n     * executeJavaScript(`console.log('Hello, Openfin')`).then(() => console.log('Javascript excuted')).catch(err => console.log(err));\n     * ```\n     *\n     * Window:\n     * ```js\n     * async function executeJavaScript(code) {\n     *     const app = await fin.Application.start({\n     *         name: 'myApp',\n     *         uuid: 'app-1',\n     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.executeJavaScript.html',\n     *         autoShow: true\n     *     });\n     *     const win = await app.getWindow();\n     *     return await win.executeJavaScript(code);\n     * }\n     *\n     * executeJavaScript(`console.log('Hello, Openfin')`).then(() => console.log('Javascript excuted')).catch(err => console.log(err));\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    executeJavaScript(code) {\n        return this.wire\n            .sendAction('execute-javascript-in-window', { ...this.identity, code })\n            .then(({ payload }) => payload.data);\n    }\n    /**\n     * Returns the zoom level of the WebContents.\n     *\n     * @example\n     * View:\n     * ```js\n     * async function getZoomLevel() {\n     *     const view = await fin.View.getCurrent();\n     *     return await view.getZoomLevel();\n     * }\n     *\n     * getZoomLevel().then(zoomLevel => console.log(zoomLevel)).catch(err => console.log(err));\n     * ```\n     *\n     * Window:\n     * ```js\n     * async function createWin() {\n     *     const app = await fin.Application.start({\n     *         name: 'myApp',\n     *         uuid: 'app-1',\n     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getZoomLevel.html',\n     *         autoShow: true\n     *     });\n     *     return await app.getWindow();\n     * }\n     *\n     * async function getZoomLevel() {\n     *     const win = await createWin();\n     *     return await win.getZoomLevel();\n     * }\n     *\n     * getZoomLevel().then(zoomLevel => console.log(zoomLevel)).catch(err => console.log(err));\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    getZoomLevel() {\n        return this.wire.sendAction('get-zoom-level', this.identity).then(({ payload }) => payload.data);\n    }\n    /**\n     * Sets the zoom level of the WebContents.\n     * @param level The zoom level\n     *\n     * @example\n     * View:\n     * ```js\n     * async function setZoomLevel(number) {\n     *     const view = await fin.View.getCurrent();\n     *     return await view.setZoomLevel(number);\n     * }\n     *\n     * setZoomLevel(4).then(() => console.log('Setting a  zoom level')).catch(err => console.log(err));\n     * ```\n     *\n     * Window:\n     * ```js\n     * async function createWin() {\n     *     const app = await fin.Application.start({\n     *         name: 'myApp',\n     *         uuid: 'app-1',\n     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.setZoomLevel.html',\n     *         autoShow: true\n     *     });\n     *     return await app.getWindow();\n     * }\n     *\n     * async function setZoomLevel(number) {\n     *     const win = await createWin();\n     *     return await win.setZoomLevel(number);\n     * }\n     *\n     * setZoomLevel(4).then(() => console.log('Setting a  zoom level')).catch(err => console.log(err));\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    setZoomLevel(level) {\n        return this.wire.sendAction('set-zoom-level', { ...this.identity, level }).then(() => undefined);\n    }\n    /**\n     * Navigates the WebContents to a specified URL.\n     *\n     * Note: The url must contain the protocol prefix such as http:// or https://.\n     * @param url - The URL to navigate the WebContents to.\n     *\n     * @example\n     * View:\n     * ```js\n     * async function createView() {\n     *     const me = await fin.Window.getCurrent();\n     *     return fin.View.create({\n     *         name: 'viewName',\n     *         target: me.identity,\n     *         bounds: {top: 10, left: 10, width: 200, height: 200}\n     *     });\n     * }\n     *\n     * createView()\n     *     .then(view => view.navigate('https://example.com'))\n     *     .then(() => console.log('navigation complete'))\n     *     .catch(err => console.log(err));\n     * ```\n     *\n     * Window:\n     * ```js\n     * async function navigate() {\n     *     const win = await fin.Window.getCurrent();\n     *     return await win.navigate('https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.navigate.html');\n     * }\n     * navigate().then(() => console.log('Navigate to tutorial')).catch(err => console.log(err));\n     * ```\n     * @experimental\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    navigate(url) {\n        return this.wire.sendAction('navigate-window', { ...this.identity, url }).then(() => undefined);\n    }\n    /**\n     * Navigates the WebContents back one page.\n     *\n     * @example\n     * View:\n     * ```js\n     * async function navigateBack() {\n     *     const view = await fin.View.wrap({ name: 'testapp-view', uuid: 'testapp' });\n     *     await view.navigate('https://www.google.com');\n     *     return await view.navigateBack();\n     * }\n     * navigateBack().then(() => console.log('Navigated back')).catch(err => console.log(err));\n     * ```\n     *\n     * Window:\n     * ```js\n     * async function navigateBack() {\n     *     const win = await fin.Window.wrap({ name: 'testapp', uuid: 'testapp' });\n     *     await win.navigate('https://www.google.com');\n     *     return await win.navigateBack();\n     * }\n     * navigateBack().then(() => console.log('Navigated back')).catch(err => console.log(err));\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    navigateBack() {\n        return this.wire.sendAction('navigate-window-back', { ...this.identity }).then(() => undefined);\n    }\n    /**\n     * Navigates the WebContents forward one page.\n     *\n     * @example\n     * View:\n     * ```js\n     * async function navigateForward() {\n     *     const view = await fin.View.getCurrent();\n     *     await view.navigate('https://www.google.com');\n     *     await view.navigateBack();\n     *     return await view.navigateForward();\n     * }\n     * navigateForward().then(() => console.log('Navigated forward')).catch(err => console.log(err));\n     * ```\n     *\n     * Window:\n     * ```js\n     * async function navigateForward() {\n     *     const win = await fin.Window.getCurrent();\n     *     await win.navigate('https://www.google.com');\n     *     await win.navigateBack();\n     *     return await win.navigateForward();\n     * }\n     * navigateForward().then(() => console.log('Navigated forward')).catch(err => console.log(err));\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    async navigateForward() {\n        await this.wire.sendAction('navigate-window-forward', { ...this.identity });\n    }\n    /**\n     * Stops any current navigation the WebContents is performing.\n     *\n     * @example\n     * View:\n     * ```js\n     * async function stopNavigation() {\n     *     const view = await fin.View.wrap({ name: 'testapp-view', uuid: 'testapp' });\n     *     await view.navigate('https://www.google.com');\n     *     return await view.stopNavigation();\n     * }\n     * stopNavigation().then(() => console.log('you shall not navigate')).catch(err => console.log(err));\n     * ```\n     *\n     * Window:\n     * ```js\n     * async function stopNavigation() {\n     *     const win = await fin.Window.wrap({ name: 'testapp', uuid: 'testapp' });\n     *     await win.navigate('https://www.google.com');\n     *     return await win.stopNavigation();\n     * }\n     * stopNavigation().then(() => console.log('you shall not navigate')).catch(err => console.log(err));\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    stopNavigation() {\n        return this.wire.sendAction('stop-window-navigation', { ...this.identity }).then(() => undefined);\n    }\n    /**\n     * Reloads the WebContents\n     *\n     * @example\n     * View:\n     * ```js\n     * async function reload() {\n     * \tconst view = await fin.View.getCurrent();\n     *     return await view.reload();\n     * }\n     *\n     * reload().then(() => {\n     * \t\tconsole.log('Reloaded view')\n     * }).catch(err => console.log(err));\n     * ```\n     *\n     * Window:\n     * ```js\n     * async function reloadWindow() {\n     * \t\tconst app = await fin.Application.start({\n     * \t\t\t\tname: 'myApp',\n     * \t\t\t\tuuid: 'app-1',\n     * \t\t\t\turl: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.reload.html',\n     * \t\t\t\tautoShow: true\n     * \t\t});\n     * \t\tconst win = await app.getWindow();\n     *     return await win.reload();\n     * }\n     *\n     * reloadWindow().then(() => {\n     * \t\tconsole.log('Reloaded window')\n     * }).catch(err => console.log(err));\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    reload(ignoreCache = false) {\n        return this.wire\n            .sendAction('reload-window', {\n            ignoreCache,\n            ...this.identity\n        })\n            .then(() => undefined);\n    }\n    /**\n     * Prints the WebContents.\n     * @param options Printer Options\n     *\n     * Note: When `silent` is set to `true`, the API will pick the system's default printer if deviceName\n     * is empty and the default settings for printing.\n     *\n     * Use the CSS style `page-break-before: always;` to force print to a new page.\n     *\n     * @example\n     * ```js\n     * const view = fin.View.getCurrentSync();\n     *\n     * view.print({ silent: false, deviceName: 'system-printer-name' }).then(() => {\n     *     console.log('print call has been sent to the system');\n     * });\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    print(options = {}) {\n        return this.wire.sendAction('print', { ...this.identity, options }).then(() => undefined);\n    }\n    /**\n     * Find and highlight text on a page.\n     * @param searchTerm Term to find in page\n     * @param options Search options\n     *\n     * Note: By default, each subsequent call will highlight the next text that matches the search term.\n     *\n     * Returns a promise with the results for the request. By subscribing to the\n     * found-in-page event, you can get the results of this call as well.\n     *\n     * @example\n     * View:\n     * ```js\n     * const view = fin.View.getCurrentSync();\n     *\n     * //By subscribing to the 'found in page' event we can get the results of each findInPage call made.\n     * view.addListener('found-in-page', (event) => {\n     *     console.log(event);\n     * });\n     *\n     * // The promise also returns the results for the request\n     * view.findInPage('a').then((result) => {\n     *     console.log(result)\n     * });\n     * ```\n     *\n     * Window:\n     * ```js\n     * const win = fin.Window.getCurrentSync();\n     *\n     * //By subscribing to the 'found in page' event we can get the results of each findInPage call made.\n     * win.addListener('found-in-page', (event) => {\n     *     console.log(event);\n     * });\n     *\n     * // The promise also returns the results for the request\n     * win.findInPage('a').then((result) => {\n     *     console.log(result)\n     * });\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    findInPage(searchTerm, options) {\n        return this.wire\n            .sendAction('find-in-page', { ...this.identity, searchTerm, options })\n            .then(({ payload }) => payload.data);\n    }\n    /**\n     * Stop a {@link View#findInPage findInPage} call by specifying any of these actions:\n     *\n     * * clearSelection - Clear the selection.\n     * * keepSelection - Translate the selection into a normal selection.\n     * * activateSelection - Focus and click the selection node.\n     *\n     * @example\n     * View:\n     * ```js\n     * const view = fin.View.getCurrentSync();\n     *\n     * view.addListener('found-in-page', (event) => {\n     *     setTimeout(() => {\n     *         view.stopFindInPage('clearSelection');\n     *     }, 5000);\n     * });\n     *\n     * view.findInPage('a').then(results => {\n     *     console.log(results);\n     * });\n     * ```\n     *\n     * Window:\n     * ```js\n     * const win = fin.Window.getCurrentSync();\n     *\n     * win.addListener('found-in-page', (event) => {\n     *     setTimeout(() => {\n     *         win.stopFindInPage('clearSelection');\n     *     }, 5000);\n     * });\n     *\n     * win.findInPage('a').then(results => {\n     *     console.log(results);\n     * });\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    stopFindInPage(action) {\n        return this.wire.sendAction('stop-find-in-page', { ...this.identity, action }).then(() => undefined);\n    }\n    /**\n     * Returns an array with all system printers\n     * @deprecated use System.getPrinters instead\n     *\n     * @example\n     * View:\n     * ```js\n     * const view = fin.View.getCurrentSync();\n     *\n     * view.getPrinters()\n     *     .then((printers) => {\n     *         printers.forEach((printer) => {\n     *             if (printer.isDefault) {\n     *                 console.log(printer);\n     *             }\n     *         });\n     *     })\n     *     .catch((err) => {\n     *         console.log(err);\n     *     });\n     * ```\n     *\n     * Window:\n     * ```js\n     * const win = fin.Window.getCurrentSync();\n     *\n     * win.getPrinters()\n     *     .then((printers) => {\n     *         printers.forEach((printer) => {\n     *             if (printer.isDefault) {\n     *                 console.log(printer);\n     *             }\n     *         });\n     *     })\n     *     .catch((err) => {\n     *         console.log(err);\n     *     });\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    getPrinters() {\n        return this.wire.sendAction('get-printers', { ...this.identity }).then(({ payload }) => payload.data);\n    }\n    /**\n     * Gives focus to the WebContents.\n     *\n     * @example\n     * ```js\n     * async function focusWindow() {\n     *     const app = await fin.Application.start({\n     *         name: 'myApp',\n     *         uuid: 'app-1',\n     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.focus.html',\n     *         autoShow: true\n     *     });\n     *     const win = await app.getWindow();\n     *     return await win.focus();\n     * }\n     *\n     * focusWindow().then(() => console.log('Window focused')).catch(err => console.log(err));\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    async focus({ emitSynthFocused } = { emitSynthFocused: true }) {\n        await this.wire.sendAction('focus-window', { emitSynthFocused, ...this.identity });\n    }\n    /**\n     * Shows the Chromium Developer Tools\n     *\n     * @example\n     * View:\n     * ```js\n     * async function showDeveloperTools() {\n     *     const view = await fin.View.getCurrent();\n     *     return view.showDeveloperTools();\n     * }\n     *\n     * showDevelopertools()\n     * .then(() => console.log('Showing dev tools'))\n     * .catch(err => console.error(err));\n     * ```\n     *\n     * Window:\n     * ```js\n     * async function showDeveloperTools() {\n     *     const win = await fin.Window.getCurrent();\n     *     return win.showDeveloperTools();\n     * }\n     *\n     * showDevelopertools()\n     * .then(() => console.log('Showing dev tools'))\n     * .catch(err => console.error(err));\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    async showDeveloperTools() {\n        // Note this hits the system action map in core state for legacy reasons.\n        await this.wire.sendAction('show-developer-tools', this.identity);\n    }\n    /**\n     * Retrieves the process information associated with a WebContents.\n     *\n     * Note: This includes any iframes associated with the WebContents\n     *\n     * @example\n     * View:\n     * ```js\n     *     const view = await fin.View.getCurrent();\n     *     const processInfo = await view.getProcessInfo();\n     * ```\n     *\n     * Window:\n     * ```js\n     *     const win = await fin.Window.getCurrent();\n     *     const processInfo = await win.getProcessInfo();\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    async getProcessInfo() {\n        const { payload: { data } } = await this.wire.sendAction('get-process-info', this.identity);\n        return data;\n    }\n    /**\n     * Retrieves information on all Shared Workers.\n     *\n     * @example\n     * View:\n     * ```js\n     *     const view = await fin.View.create({\n     *         name: 'viewName',\n     *         target: fin.me.identity,\n     *         bounds: {top: 10, left: 10, width: 200, height: 200}\n     *     });\n     *\n     *     await view.navigate('https://mdn.github.io/dom-examples/web-workers/simple-shared-worker/');\n     *\n     *     const sharedWorkers = await view.getSharedWorkers();\n     * ```\n     *\n     * Window:\n     * ```js\n     *     const winOption = {\n     *         name:'child',\n     *         defaultWidth: 300,\n     *         defaultHeight: 300,\n     *         url: 'https://mdn.github.io/dom-examples/web-workers/simple-shared-worker/',\n     *         frame: true,\n     *         autoShow: true\n     *     };\n     *     const win = await fin.Window.create(winOption);\n     *     const sharedWorkers = await win.getSharedWorkers();\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    async getSharedWorkers() {\n        return this.wire.sendAction('get-shared-workers', this.identity).then(({ payload }) => payload.data);\n    }\n    /**\n     * Opens the developer tools for the shared worker context.\n     *\n     * @example\n     * View:\n     * ```js\n     *     const view = await fin.View.create({\n     *         name: 'viewName',\n     *         target: fin.me.identity,\n     *         bounds: {top: 10, left: 10, width: 200, height: 200}\n     *     });\n     *\n     *     await view.navigate('https://mdn.github.io/dom-examples/web-workers/simple-shared-worker/');\n     *\n     *     await view.inspectSharedWorker();\n     * ```\n     *\n     * Example:\n     * ```js\n     *     const winOption = {\n     *         name:'child',\n     *         defaultWidth: 300,\n     *         defaultHeight: 300,\n     *         url: 'https://mdn.github.io/dom-examples/web-workers/simple-shared-worker/',\n     *         frame: true,\n     *         autoShow: true\n     *     };\n     *     const win = await fin.Window.create(winOption);\n     *     await win.inspectSharedWorker();\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    async inspectSharedWorker() {\n        await this.wire.sendAction('inspect-shared-worker', { ...this.identity });\n    }\n    /**\n     * Inspects the shared worker based on its ID.\n     * @param workerId - The id of the shared worker.\n     *\n     * @example\n     * View:\n     * ```js\n     *     const view = await fin.View.create({\n     *         name: 'viewName',\n     *         target: fin.me.identity,\n     *         bounds: {top: 10, left: 10, width: 200, height: 200}\n     *     });\n     *\n     *     await view.navigate('https://mdn.github.io/dom-examples/web-workers/simple-shared-worker/');\n     *\n     *     const sharedWorkers = await view.getSharedWorkers();\n     *     await view.inspectSharedWorkerById(sharedWorkers[0].id);\n     * ```\n     *\n     * Window:\n     * ```js\n     *     const winOption = {\n     *         name:'child',\n     *         defaultWidth: 300,\n     *         defaultHeight: 300,\n     *         url: 'https://mdn.github.io/dom-examples/web-workers/simple-shared-worker/',\n     *         frame: true,\n     *         autoShow: true\n     *     };\n     *     const win = await fin.Window.create(winOption);\n     *     const sharedWorkers = await win.getSharedWorkers();\n     *     await win.inspectSharedWorkerById(sharedWorkers[0].id);\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    async inspectSharedWorkerById(workerId) {\n        await this.wire.sendAction('inspect-shared-worker-by-id', { ...this.identity, workerId });\n    }\n    /**\n     * Opens the developer tools for the service worker context.\n     *\n     * @example\n     * View:\n     * ```js\n     *     const view = await fin.View.create({\n     *         name: 'viewName',\n     *         target: fin.me.identity,\n     *         bounds: {top: 10, left: 10, width: 200, height: 200}\n     *     });\n     *\n     *     await view.navigate('http://googlechrome.github.io/samples/service-worker/basic/index.html');\n     *\n     *     await view.inspectServiceWorker();\n     * ```\n     *\n     * Window:\n     * ```js\n     *     const winOption = {\n     *         name:'child',\n     *         defaultWidth: 300,\n     *         defaultHeight: 300,\n     *         url: 'http://googlechrome.github.io/samples/service-worker/basic/index.html',\n     *         frame: true,\n     *         autoShow: true\n     *     };\n     *     const win = await fin.Window.create(winOption);\n     *     await win.inspectServiceWorker();\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    async inspectServiceWorker() {\n        await this.wire.sendAction('inspect-service-worker', { ...this.identity });\n    }\n    /**\n     * Shows a popup window.\n     *\n     * Note: If this WebContents is a view and its attached window has a popup open, this will close it.\n     *\n     * Shows a popup window. Including a `name` in `options` will attempt to show an existing window as a popup, if\n     * that window doesn't exist or no `name` is included a window will be created. If the caller view or the caller\n     * view's parent window currently has a popup window open, calling `showPopupWindow` again will dismiss the currently\n     * open popup window before showing the new popup window. Also, if the caller view is destroyed or detached, the popup\n     * will be dismissed.\n     *\n     * Note: in the case where the window being shown as a popup needs to be created, it is a child of the caller view's parent window.\n     *\n     * @example\n     *\n     * Create and show a single-use popup window that returns a single result to the caller. `initialOptions` allows\n     * us to pass window options to the popup window that will be created. `resultDispatchBehavior: 'close'` ensures\n     * that once the popup window calls `dispatchPopupResult` it is closed. `blurBehavior: 'close'` will yield a dismissed\n     * result should the popup window lose focus.\n     *\n     * ```js\n     * const result = await fin.me.showPopupWindow({\n     *     initialOptions: {\n     *         frame: false\n     *     },\n     *     url: '<my_popup_url>',\n     *     resultDispatchBehavior: 'close',\n     *     blurBehavior: 'close',\n     *     focus: true,\n     *     height: 300,\n     *     width: 300,\n     *     x: 0,\n     *     y: 0\n     * });\n     * ```\n     *\n     * Same as above but using an existing window as a popup by referencing its `name`:\n     *\n     * Note: if a window with the `name` provided doesn't exist, it will be created.\n     *\n     * ```js\n     * const result = await fin.me.showPopupWindow({\n     *     initialOptions: {\n     *         frame: true\n     *     },\n     *     name: 'my-popup', // shows the 'my-popup' window if it exists, otherwise creates it\n     *     url: '<my_popup_url>', // navigates to this url if it doesn't match the location.href of the 'my-popup' window\n     *     resultDispatchBehavior: 'close',\n     *     blurBehavior: 'close',\n     *     focus: true,\n     *     hideOnClose: true, // persist window on 'dismissed' result, alternatively change onResultDispatch and blurBehavior to 'hide'\n     *     height: 300,\n     *     width: 300,\n     *     x: 0,\n     *     y: 0\n     * });\n     * ```\n     *\n     * Create and show a popup window that is able to return multiple results to the caller via an `onPopupResult` callback. Each\n     * time the popup window calls `dispatchPopupResult`, the callback will be executed on the result. Once the popup window is\n     * closed or hidden, the `showPopupWindow` promise will resolve with a `dismissed` result that will include the most recently\n     * dispatched result as `lastDispatchResult`:\n     *\n     * ```js\n     * const popupResultCallback = (payload) => {\n     *        if (payload.result === 'clicked') {\n     *            if (payload.data.topic === 'color-changed') {\n     *                // do something like\n     *                // setColor(payload.data.value);\n     *            }\n     *        }\n     * };\n     *\n     * await fin.me.showPopupWindow({\n     *     initialOptions: {\n     *         frame: false\n     *     },\n     *     url: '<my_popup_url>',\n     *     resultDispatchBehavior: 'none',\n     *     blurBehavior: 'close',\n     *     focus: true,\n     *     height: 300,\n     *     width: 300,\n     *     x: 0,\n     *     y: 0,\n     *     onPopupResult: popupResultCallback\n     * });\n     * ```\n     *\n     * Same as above but using an existing window as a popup:\n     *\n     * ```js\n     * const popupResultCallback = (payload) => {\n     *        if (payload.result === 'clicked') {\n     *            if (payload.data.topic === 'color-changed') {\n     *                // do something like\n     *                // setColor(payload.data.value);\n     *            }\n     *        }\n     * };\n     *\n     * await fin.me.showPopupWindow({\n     *     initialOptions: {\n     *         frame: false\n     *     },\n     *     name: 'my-popup', // shows the 'my-popup' window if it exists, otherwise creates it\n     *     url: '<my_popup_url>', // navigates to this url if it doesn't match the location.href of the 'my-popup' window\n     *     resultDispatchBehavior: 'none',\n     *     blurBehavior: 'hide',\n     *     focus: true,\n     *     hideOnClose: true, // we can just use this or we can change blurBehavior to 'hide'\n     *     height: 300,\n     *     width: 300,\n     *     x: 0,\n     *     y: 0,\n     *     onPopupResult: popupResultCallback\n     * });\n     * ```\n     *\n     * Create or show a popup window that disables user movement (positioning and resizing) in the caller\n     * view's parent window by using `blurBehavior: 'modal'`:\n     *\n     * ```js\n     * const result = await fin.me.showPopupWindow({\n     *     initialOptions: {\n     *         frame: false\n     *     },\n     *     url: '<my_popup_url>',\n     *     resultDispatchBehavior: 'close',\n     *     blurBehavior: 'modal',\n     *     focus: true,\n     *     height: 300,\n     *     width: 300,\n     *     x: 0,\n     *     y: 0\n     * });\n     * ```\n     *\n     * Create a popup window as a modal:\n     *\n     * Note: The only way to ensure true modal behavior is to create the window being shown as a popup with a\n     * `modalParentIdentity` that uses the caller view's parent window identity.\n     *\n     * ```js\n     * const result = await fin.me.showPopupWindow({\n     *     initialOptions: {\n     *         frame: false,\n     *         modalParentIdentity: fin.me.identity\n     *     },\n     *     url: '<my_popup_url>',\n     *     resultDispatchBehavior: 'close',\n     *     blurBehavior: 'modal',\n     *     focus: true,\n     *     height: 300,\n     *     width: 300,\n     *     x: 0,\n     *     y: 0\n     * });\n     * ```\n     *\n     * Pass data to a popup window that is available when the popup is shown.\n     *\n     * Note: this is just one example for a use of `additionalOptions`, it can be used to update any updatable\n     * window options when creating or showing an existing window as a popup.\n     *\n     * ```js\n     * const result = await fin.me.showPopupWindow({\n     *     additionalOptions: {\n     *         customData: {\n     *             foo: 'bar'\n     *         }\n     *     },\n     *     url: '<my_popup_url>',\n     *     resultDispatchBehavior: 'close',\n     *     blurBehavior: 'close',\n     *     focus: true,\n     *     height: 300,\n     *     width: 300,\n     *     x: 0,\n     *     y: 0\n     * });\n     *\n     * // Access from the popup window context like so:\n     * const { customData } = await fin.me.getOptions();\n     * const { foo } = customData;\n     * ```\n     *\n     * Execute a callback on the popup's OpenFin window when the popup is shown:\n     *\n     * ```js\n     * const popupWindowCallback = async (win) => {\n     *     await win.flash();\n     * };\n     *\n     * const result = await fin.me.showPopupWindow({\n     *     url: '<my_popup_url>',\n     *     resultDispatchBehavior: 'close',\n     *     blurBehavior: 'close',\n     *     focus: true,\n     *     height: 300,\n     *     width: 300,\n     *     x: 0,\n     *     y: 0,\n     *     onPopupReady: popupWindowCallback;\n     * });\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    async showPopupWindow(options) {\n        this.wire.sendAction(`${this.entityType}-show-popup-window`, this.identity).catch(() => {\n            // we do not want to expose this error, just continue if this analytics-only call fails\n        });\n        if (options?.onPopupReady) {\n            const readyListener = async ({ popupName }) => {\n                try {\n                    const popupWindow = this.fin.Window.wrapSync({ uuid: this.fin.me.uuid, name: popupName });\n                    await options.onPopupReady(popupWindow);\n                }\n                catch (error) {\n                    throw new Error(`Something went wrong during onPopupReady execution: ${error}`);\n                }\n            };\n            // TODO: fix typing (internal)\n            // @ts-expect-error\n            await this.once('popup-ready', readyListener);\n        }\n        const { payload: tryCreatePayload } = await this.wire.sendAction('try-create-popup-window', {\n            options: {\n                ...options,\n                // Internal use only.\n                // @ts-expect-error\n                hasResultCallback: !!options?.onPopupResult,\n                hasReadyCallback: !!options?.onPopupReady\n            },\n            ...this.identity\n        });\n        const { data: { willOpen, options: popupOptions } } = tryCreatePayload;\n        if (willOpen) {\n            // Solve the issue where Interop in a popup window with non cross-origin url is not working(core-1076).\n            await this.fin.Window.create(popupOptions.initialOptions);\n        }\n        const normalizePopupResult = (payload) => {\n            const { name, uuid, result, data } = payload;\n            const popupResult = {\n                identity: {\n                    name,\n                    uuid\n                },\n                result\n            };\n            if (data) {\n                popupResult.data = data;\n            }\n            return popupResult;\n        };\n        if (options?.onPopupResult) {\n            const dispatchResultListener = async (payload) => {\n                await options.onPopupResult(normalizePopupResult(payload));\n            };\n            const teardownListener = async () => {\n                // TODO: fix typing (internal)\n                // @ts-expect-error\n                await this.removeListener('popup-result', dispatchResultListener);\n            };\n            // TODO: fix typing (internal)\n            // @ts-expect-error\n            await this.on('popup-result', dispatchResultListener);\n            // TODO: fix typing (internal)\n            // hilariously this does not need a ts-expect-error - this is gap in type soundness\n            // should investigate - probably due to `teardownListener` taking a void argument\n            // which might play nicely with the `never` type?  huh...\n            await this.once('popup-teardown', teardownListener);\n        }\n        const { payload } = await this.wire.sendAction('show-popup-window', {\n            options: popupOptions,\n            ...this.identity\n        });\n        return payload.data;\n    }\n}\nmain.WebContents = WebContents;\n\nvar hasRequiredInstance$2;\n\nfunction requireInstance$2 () {\n\tif (hasRequiredInstance$2) return Instance$5;\n\thasRequiredInstance$2 = 1;\n\tvar __classPrivateFieldGet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n\t    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n\t    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n\t    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n\t};\n\tvar _View_providerChannelClient;\n\tObject.defineProperty(Instance$5, \"__esModule\", { value: true });\n\tInstance$5.View = void 0;\n\tconst transport_errors_1 = transportErrors;\n\tconst lazy_1 = lazy;\n\tconst layout_entities_1 = layoutEntities;\n\tconst layout_constants_1 = layout_constants;\n\tconst main_1 = main;\n\tconst window_1 = requireWindow();\n\t/**\n\t * A View can be used to embed additional web content into a Window.\n\t * It is like a child window, except it is positioned relative to its owning window.\n\t * It has the ability to listen for {@link OpenFin.ViewEvents View-specific events}.\n\t *\n\t * By default, a View will try to share the same renderer process as other Views owned by its parent Application.\n\t * To change that behavior, see the processAffinity {@link OpenFin.ViewOptions view option}.\n\t *\n\t * A View's lifecycle is tied to its owning window and can be re-attached to a different window at any point during its lifecycle.\n\t */\n\tclass View extends main_1.WebContents {\n\t    /**\n\t     * @internal\n\t     */\n\t    constructor(wire, identity) {\n\t        super(wire, identity, 'view');\n\t        this.identity = identity;\n\t        _View_providerChannelClient.set(this, new lazy_1.Lazy(() => {\n\t            const platform = this.fin.Platform.wrapSync(this.identity);\n\t            return platform.getClient();\n\t        }));\n\t        /**\n\t         * Attaches the current view to the given window identity.\n\t         * Identity must be the identity of a window in the same application.\n\t         * This detaches the view from its current window, and sets the view to be destroyed when its new window closes.\n\t         *\n\t         * @example\n\t         * ```js\n\t         * let view;\n\t         * async function createView() {\n\t         *     const me = await fin.Window.getCurrent();\n\t         *     return fin.View.create({\n\t         *         name: 'viewNameAttach',\n\t         *         target: me.identity,\n\t         *         bounds: {top: 10, left: 10, width: 200, height: 200}\n\t         *     });\n\t         * }\n\t         *\n\t         * async function attachView() {\n\t         *     view = await createView();\n\t         *     console.log('View created.');\n\t         *\n\t         *     await view.navigate('https://google.com');\n\t         *     console.log('View navigated to given url.');\n\t         *\n\t         *     const winOption = {\n\t         *         name:'winOptionName',\n\t         *         defaultWidth: 300,\n\t         *         defaultHeight: 300,\n\t         *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.create.html',\n\t         *         frame: true,\n\t         *         autoShow: true\n\t         *     };\n\t         *     const newWindow = await fin.Window.create(winOption);\n\t         *     view.attach(newWindow.identity);\n\t         * }\n\t         *\n\t         * attachView()\n\t         *     .then(() => console.log('View attached to new window.'))\n\t         *     .catch(err => console.log(err));\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.attach = async (target) => {\n\t            await this.wire.sendAction('attach-view', { target, ...this.identity });\n\t        };\n\t        /**\n\t         * Destroys the current view\n\t         *\n\t         * @example\n\t         * ```js\n\t         * const view = fin.View.wrapSync({ uuid: 'viewUuid', name: 'viewName' });\n\t         * view.destroy();\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.destroy = async () => {\n\t            await this.wire.sendAction('destroy-view', { ...this.identity });\n\t        };\n\t        /**\n\t         * Shows the current view if it is currently hidden.\n\t         *\n\t         * @example\n\t         * ```js\n\t         * let view;\n\t         * async function createView() {\n\t         *     const me = await fin.Window.getCurrent();\n\t         *     return fin.View.create({\n\t         *         name: 'viewNameShow',\n\t         *         target: me.identity,\n\t         *         bounds: {top: 10, left: 10, width: 200, height: 200}\n\t         *     });\n\t         * }\n\t         *\n\t         * async function hideAndShowView() {\n\t         *     view = await createView();\n\t         *     console.log('View created.');\n\t         *\n\t         *     await view.navigate('https://google.com');\n\t         *     console.log('View navigated to given url option.');\n\t         *\n\t         *     await view.hide();\n\t         *     console.log(\"View hidden.\");\n\t         *\n\t         *     view.show();\n\t         *     console.log(\"View shown.\");\n\t         * }\n\t         *\n\t         * hideAndShowView()\n\t         *     .then(() => console.log('View hidden and shown.'))\n\t         *     .catch(err => console.log(err));\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.show = async () => {\n\t            await this.wire.sendAction('show-view', { ...this.identity });\n\t        };\n\t        /**\n\t         * Sets the bounds (top, left, width, height) of the view relative to its window and shows it if it is hidden.\n\t         * This method ensures the view is both positioned and showing. It will reposition a visible view and both show and reposition a hidden view.\n\t         *\n\t         * @remarks View position is relative to the bounds of the window.\n\t         * ({top: 0, left: 0} represents the top left corner of the window)\n\t         *\n\t         * @example\n\t         * ```js\n\t         * let view;\n\t         * async function createView() {\n\t         *     const me = await fin.Window.getCurrent();\n\t         *     return fin.View.create({\n\t         *         name: 'viewNameSetBounds',\n\t         *         target: me.identity,\n\t         *         bounds: {top: 10, left: 10, width: 200, height: 200}\n\t         *     });\n\t         * }\n\t         *\n\t         * async function showViewAt() {\n\t         *     view = await createView();\n\t         *     console.log('View created.');\n\t         *\n\t         *     await view.navigate('https://google.com');\n\t         *     console.log('View navigated to given url.');\n\t         *\n\t         *     await view.showAt({\n\t         *         top: 100,\n\t         *         left: 100,\n\t         *         width: 300,\n\t         *         height: 300\n\t         *     }, {\n\t         *       bringToFront : true\n\t         *     });\n\t         * }\n\t         *\n\t         * showViewAt()\n\t         *     .then(() => console.log('View set to new bounds and shown.'))\n\t         *     .catch(err => console.log(err));\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.showAt = async (bounds, options = {}) => {\n\t            await this.wire.sendAction('show-view-at', { bounds, ...this.identity, options });\n\t        };\n\t        /**\n\t         * Brings the specified view to the front of its current window. This ensures the view will be visible on top of any other views\n\t         * which have overlapping bounds with it.\n\t         *\n\t         * Please note, this is not a permanent action - when a new view is created or attached to the window, it will display on top of all other views\n\t         * in the window that share bounds with it.\n\t         */\n\t        this.bringToFront = async () => {\n\t            await this.wire.sendAction('bring-view-to-front', { ...this.identity });\n\t        };\n\t        /**\n\t         * Hides the current view if it is currently visible.\n\t         *\n\t         * @example\n\t         * ```js\n\t         * let view;\n\t         * async function createView() {\n\t         *     const me = await fin.Window.getCurrent();\n\t         *     return fin.View.create({\n\t         *         name: 'viewNameHide',\n\t         *         target: me.identity,\n\t         *         bounds: {top: 10, left: 10, width: 200, height: 200}\n\t         *     });\n\t         * }\n\t         *\n\t         * async function hideView() {\n\t         *     view = await createView();\n\t         *     console.log('View created.');\n\t         *\n\t         *     await view.navigate('https://google.com');\n\t         *     console.log('View navigated to given url.');\n\t         *\n\t         *     await view.hide();\n\t         * }\n\t         *\n\t         * hideView()\n\t         *     .then(() => console.log('View hidden.'))\n\t         *     .catch(err => console.log(err));\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.hide = async () => {\n\t            await this.wire.sendAction('hide-view', { ...this.identity });\n\t        };\n\t        /**\n\t         * Sets the bounds (top, left, width, height) of the view relative to its window.\n\t         *\n\t         * @remarks View position is relative to the bounds of the window.\n\t         * ({top: 0, left: 0} represents the top left corner of the window)\n\t         *\n\t         * @example\n\t         * ```js\n\t         * let view;\n\t         * async function createView() {\n\t         *     const me = await fin.Window.getCurrent();\n\t         *     return fin.View.create({\n\t         *         name: 'viewNameSetBounds',\n\t         *         target: me.identity,\n\t         *         bounds: {top: 10, left: 10, width: 200, height: 200}\n\t         *     });\n\t         * }\n\t         *\n\t         * async function setViewBounds() {\n\t         *     view = await createView();\n\t         *     console.log('View created.');\n\t         *\n\t         *     await view.navigate('https://google.com');\n\t         *     console.log('View navigated to given url.');\n\t         *\n\t         *     await view.setBounds({\n\t         *         top: 100,\n\t         *         left: 100,\n\t         *         width: 300,\n\t         *         height: 300\n\t         *     });\n\t         * }\n\t         *\n\t         * setViewBounds()\n\t         *     .then(() => console.log('View set to new bounds.'))\n\t         *     .catch(err => console.log(err));\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.setBounds = async (bounds) => {\n\t            await this.wire.sendAction('set-view-bounds', { bounds, ...this.identity });\n\t        };\n\t        /**\n\t         * Gets the bounds (top, left, width, height) of the view relative to its window.\n\t         *\n\t         * @remarks View position is relative to the bounds of the window.\n\t         * ({top: 0, left: 0} represents the top left corner of the window)\n\t         *\n\t         * @example\n\t         * ```js\n\t         * const view = await fin.View.create({\n\t         *     name: 'viewNameSetBounds',\n\t         *     target: fin.me.identity,\n\t         *     bounds: {top: 10, left: 10, width: 200, height: 200}\n\t         * });\n\t         *\n\t         * await view.navigate('https://google.com');\n\t         *\n\t         * await view.setBounds({\n\t         *     top: 100,\n\t         *     left: 100,\n\t         *     width: 300,\n\t         *     height: 300\n\t         * });\n\t         *\n\t         * console.log(await view.getBounds());\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.getBounds = async () => {\n\t            const ack = await this.wire.sendAction('get-view-bounds', { ...this.identity });\n\t            return ack.payload.data;\n\t        };\n\t        /**\n\t         * Gets the View's info.\n\t         *\n\t         * @example\n\t         * ```js\n\t         * let view;\n\t         * async function createView() {\n\t         *     const me = await fin.Window.getCurrent();\n\t         *     return fin.View.create({\n\t         *         name: 'viewNameGetInfo',\n\t         *         target: me.identity,\n\t         *         bounds: {top: 10, left: 10, width: 200, height: 200}\n\t         *     });\n\t         * }\n\t         *\n\t         * async function getViewInfo() {\n\t         *     view = await createView();\n\t         *     console.log('View created.');\n\t         *\n\t         *     await view.navigate('https://google.com');\n\t         *     console.log('View navigated to given url.');\n\t         *\n\t         *     return view.getInfo();\n\t         * }\n\t         *\n\t         * getViewInfo()\n\t         *     .then((info) => console.log('View info fetched.', info))\n\t         *     .catch(err => console.log(err));\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.getInfo = async () => {\n\t            const ack = await this.wire.sendAction('get-view-info', { ...this.identity });\n\t            return ack.payload.data;\n\t        };\n\t        /**\n\t         * Retrieves the layout for the window the view is attached to.\n\t         *\n\t         * @example\n\t         * ```js\n\t         *     //get the current View\n\t         *     const view = await fin.View.getCurrent();\n\t         *\n\t         *     //get a reference to the Layout for the Window the view is part of\n\t         *     const layout = await view.getParentLayout();\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.getParentLayout = async () => {\n\t            this.wire.sendAction('view-get-parent-layout', { ...this.identity }).catch(() => {\n\t                // don't expose\n\t            });\n\t            const layoutWindow = await this.getCurrentWindow();\n\t            let layoutWindowIdentity = layoutWindow.identity;\n\t            // TODO: CORE-1857 - when we tearout active layout or drag a view out of a window, the above identity includes the whole window info.\n\t            if (layoutWindowIdentity.identity) {\n\t                layoutWindowIdentity = layoutWindowIdentity.identity;\n\t            }\n\t            try {\n\t                const providerChannelClient = await __classPrivateFieldGet(this, _View_providerChannelClient, \"f\").getValue();\n\t                const client = await layout_entities_1.LayoutNode.newLayoutEntitiesClient(providerChannelClient, layout_constants_1.LAYOUT_CONTROLLER_ID, layoutWindowIdentity);\n\t                const layoutIdentity = await client.getLayoutIdentityForViewOrThrow(this.identity);\n\t                return this.fin.Platform.Layout.wrap(layoutIdentity);\n\t            }\n\t            catch (e) {\n\t                const allowedErrors = [\n\t                    'No action registered at target for',\n\t                    'getLayoutIdentityForViewOrThrow is not a function'\n\t                ];\n\t                if (!allowedErrors.some((m) => e.message.includes(m))) {\n\t                    throw e;\n\t                }\n\t                // fallback logic for missing endpoint\n\t                return this.fin.Platform.Layout.wrap(layoutWindowIdentity);\n\t            }\n\t        };\n\t        /**\n\t         * Gets the View's options.\n\t         *\n\t         * @example\n\t         * ```js\n\t         * let view;\n\t         * async function createView() {\n\t         *     const me = await fin.Window.getCurrent();\n\t         *     return fin.View.create({\n\t         *         name: 'viewNameGetOptions',\n\t         *         target: me.identity,\n\t         *         bounds: {top: 10, left: 10, width: 200, height: 200}\n\t         *     });\n\t         * }\n\t         *\n\t         * async function getViewOptions() {\n\t         *     view = await createView();\n\t         *     console.log('View created.');\n\t         *\n\t         *     await view.navigate('https://google.com');\n\t         *     console.log('View navigated to given url.');\n\t         *\n\t         *     const me = await fin.Window.getCurrent();\n\t         *     view = fin.View.wrapSync({ uuid: me.identity.uuid, name: 'viewNameGetOptions' });\n\t         *     return view.getOptions();\n\t         * }\n\t         *\n\t         * getViewOptions()\n\t         *     .then((info) => console.log('View options fetched.', info))\n\t         *     .catch(err => console.log(err));\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.getOptions = async () => {\n\t            return this.wire.sendAction('get-view-options', { ...this.identity }).then(({ payload }) => payload.data);\n\t        };\n\t        /**\n\t         * Updates the view's options.\n\t         *\n\t         * @example\n\t         * ```js\n\t         * let view;\n\t         * async function createView() {\n\t         *     const me = await fin.Window.getCurrent();\n\t         *     return fin.View.create({\n\t         *         url: 'https://google.com',\n\t         *         name: 'viewNameUpdateOptions',\n\t         *         target: me.identity,\n\t         *         bounds: {top: 10, left: 10, width: 200, height: 200}\n\t         *     });\n\t         * }\n\t         *\n\t         * async function updateViewOptions() {\n\t         *     view = await createView();\n\t         *     console.log('View created.');\n\t         *\n\t         *     await view.navigate('https://google.com');\n\t         *     console.log('View navigated to given url option.');\n\t         *\n\t         *     const newOptions = { autoResize: {\n\t         *         width: true,\n\t         *         horizontal: true\n\t         *     }};\n\t         *     return view.updateOptions(newOptions);\n\t         * }\n\t         *\n\t         * updateViewOptions()\n\t         *     .then(payload => console.log('View options updated: ', payload))\n\t         *     .catch(err => console.log(err));\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.updateOptions = async (options) => {\n\t            return this.wire.sendAction('update-view-options', { options, ...this.identity }).then(() => undefined);\n\t        };\n\t        /**\n\t         * Retrieves the window the view is currently attached to.\n\t         *\n\t         * @example\n\t         * ```js\n\t         * const view = fin.View.wrapSync({ uuid: 'viewUuid', name: 'viewName' });\n\t         * view.getCurrentWindow()\n\t         *     .then(win => console.log('current window', win))\n\t         *     .catch(err => console.log(err));)\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.getCurrentWindow = async () => {\n\t            const { payload: { data } } = await this.wire.sendAction('get-view-window', { ...this.identity });\n\t            return new window_1._Window(this.wire, data);\n\t        };\n\t        /**\n\t         * Retrieves the current {@link OpenFin.TabStack} of the view if it belongs to one.\n\t         * @returns this view belongs to.\n\t         * @throws if this view does not belong to a TabStack or if the window has been destroyed.\n\t         * @example\n\t         * ```js\n\t         * if (!fin.me.isView) {\n\t         *     throw new Error('Not running in a platform View.');\n\t         * }\n\t         *\n\t         * const stack = await fin.me.getCurrentStack();\n\t         * // Alternatively, you can wrap any view and get the stack from there\n\t         * // const viewFromSomewhere = fin.View.wrapSync(someView.identity);\n\t         * // const stack = await viewFromSomewhere.getCurrentStack();\n\t         * const views = await stack.getViews();\n\t         * console.log(`Stack contains ${views.length} view(s)`);\n\t         * ```\n\t         */\n\t        this.getCurrentStack = async () => {\n\t            this.wire.sendAction('view-get-current-stack').catch(() => {\n\t                // don't expose\n\t            });\n\t            try {\n\t                const layoutWindow = await this.getCurrentWindow();\n\t                const providerChannelClient = await __classPrivateFieldGet(this, _View_providerChannelClient, \"f\").getValue();\n\t                const client = await layout_entities_1.LayoutNode.newLayoutEntitiesClient(providerChannelClient, layout_constants_1.LAYOUT_CONTROLLER_ID, layoutWindow.identity);\n\t                const stackDefinition = (await client.getStackByView(this.identity));\n\t                return layout_entities_1.LayoutNode.getEntity(stackDefinition, client);\n\t            }\n\t            catch (error) {\n\t                throw new transport_errors_1.RuntimeError({ reason: 'This view does not belong to a stack.', error });\n\t            }\n\t        };\n\t        /**\n\t         * Triggers the before-unload handler for the View, if one is set.\n\t         *\n\t         * @remarks Returns `true` if the handler is trying to prevent the View from unloading, and `false` if it isn't.\n\t         * Only enabled when setting enableBeforeUnload: true in your View options. If this option is not enabled it will\n\t         * always return false.\n\t         *\n\t         * This method is used internally by the Platform Provider to determine the status of each before unload handler in Views when closing the Window.\n\t         *\n\t         * @example\n\t         *\n\t         * ```js\n\t         * // from inside a View context\n\t         * const unloadPrevented = await fin.me.triggerBeforeUnload();\n\t         * ```\n\t         *\n\t         * @experimental\n\t         */\n\t        this.triggerBeforeUnload = async () => {\n\t            const message = await this.wire.sendAction('trigger-before-unload', { ...this.identity });\n\t            return message.payload.data;\n\t        };\n\t        /**\n\t         * **NOTE**: Internal use only.\n\t         * Attaches this view to an HTML element in the current context. The view will resize responsively when the element bounds change.\n\t         *\n\t         * **Known issue**: View.bindToElement does not track position changes, if the element has fixed px width and height values it is possible for the view to not update responsively.\n\t         *\n\t         * **Known issue**: When View.bindToElement is used on a element that takes up the entire page in a platform window, the bound view will not respond responsively when the window is resized to be smaller.\n\t         *\n\t         * @param element - HTML element to attach the view to.\n\t         * @returns - Cleanup function that will disconnect the element resize observer.\n\t         * @internal\n\t         * @experimental\n\t         * @remarks View will resize accordingly when the element is resized. If the element is repositioned in the DOM the view will not be repositioned, to handle this case call `bindToElement` again once the element changes position.\n\t         *\n\t         * @example\n\t         * ```html\n\t         * <div id=\"view-container\"></div>\n\t         * <script>\n\t         *     async function createAndAttachView() {\n\t         *         const url = 'https://example.com';\n\t         *         const elementId = 'view-container';\n\t         *         const element = document.getElementById(elementId);\n\t         *         const view = await fin.View.create({\n\t         *             name: 'my-view',\n\t         *             url,\n\t         *             target: fin.me.identity\n\t         *         });\n\t         *         await view.navigate(url);\n\t         *         await view.bindToElement(element);\n\t         *     }\n\t         *     createAndAttachView().catch(console.error);\n\t         * </script>\n\t         * ```\n\t         */\n\t        this.bindToElement = async (element) => {\n\t            if (!element) {\n\t                throw new Error('Element not found.');\n\t            }\n\t            const onChange = async (bounds) => this.setBounds(bounds);\n\t            return this.wire.environment.observeBounds(element, onChange);\n\t        };\n\t    }\n\t    /**\n\t     * Focuses the view\n\t     *\n\t     * @example\n\t     * ```js\n\t     * const view = fin.View.wrapSync({ uuid: 'viewUuid', name: 'viewName' });\n\t     * await view.focus();\n\t     * // do things with the focused view\n\t     * ```\n\t     * @experimental\n\t     */\n\t    async focus({ emitSynthFocused } = { emitSynthFocused: true }) {\n\t        const win = await this.getCurrentWindow();\n\t        await win.focusedWebViewWasChanged();\n\t        await super.focus({ emitSynthFocused });\n\t    }\n\t}\n\tInstance$5.View = View;\n\t_View_providerChannelClient = new WeakMap();\n\treturn Instance$5;\n}\n\nvar hasRequiredView;\n\nfunction requireView () {\n\tif (hasRequiredView) return view;\n\thasRequiredView = 1;\n\t(function (exports) {\n\t\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t\t    if (k2 === undefined) k2 = k;\n\t\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t\t    }\n\t\t    Object.defineProperty(o, k2, desc);\n\t\t}) : (function(o, m, k, k2) {\n\t\t    if (k2 === undefined) k2 = k;\n\t\t    o[k2] = m[k];\n\t\t}));\n\t\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t\t};\n\t\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t\t/**\n\t\t * Entry points for the OpenFin `View` API (`fin.View`).\n\t\t *\n\t\t * * {@link ViewModule} contains static members of the `View` API, accessible through `fin.View`.\n\t\t * * {@link View} describes an instance of an OpenFin View, e.g. as returned by `fin.View.getCurrent`.\n\t\t *\n\t\t * These are separate code entities, and are documented separately.  In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/32.114.76.10/index.html),\n\t\t * both of these were documented on the same page.\n\t\t *\n\t\t * @packageDocumentation\n\t\t */\n\t\t__exportStar(requireFactory$3(), exports);\n\t\t__exportStar(requireInstance$2(), exports); \n\t} (view));\n\treturn view;\n}\n\nvar hasRequiredInstance$1;\n\nfunction requireInstance$1 () {\n\tif (hasRequiredInstance$1) return Instance$6;\n\thasRequiredInstance$1 = 1;\n\tObject.defineProperty(Instance$6, \"__esModule\", { value: true });\n\tInstance$6.Application = void 0;\n\t/* eslint-disable import/prefer-default-export */\n\tconst base_1 = base;\n\tconst window_1 = requireWindow();\n\tconst view_1 = requireView();\n\t/**\n\t * An object representing an application. Allows the developer to create,\n\t * execute, show/close an application as well as listen to {@link OpenFin.ApplicationEvents application events}.\n\t */\n\tclass Application extends base_1.EmitterBase {\n\t    /**\n\t     * @internal\n\t     */\n\t    constructor(wire, identity) {\n\t        super(wire, 'application', identity.uuid);\n\t        this.identity = identity;\n\t        this.window = new window_1._Window(this.wire, {\n\t            uuid: this.identity.uuid,\n\t            name: this.identity.uuid\n\t        });\n\t    }\n\t    windowListFromIdentityList(identityList) {\n\t        const windowList = [];\n\t        identityList.forEach((identity) => {\n\t            windowList.push(new window_1._Window(this.wire, {\n\t                uuid: identity.uuid,\n\t                name: identity.name\n\t            }));\n\t        });\n\t        return windowList;\n\t    }\n\t    /**\n\t     * Determines if the application is currently running.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function isAppRunning() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.isRunning();\n\t     * }\n\t     * isAppRunning().then(running => console.log(`Current app is running: ${running}`)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    isRunning() {\n\t        return this.wire.sendAction('is-application-running', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Closes the application and any child windows created by the application.\n\t     * Cleans the application from state so it is no longer found in getAllApplications.\n\t     * @param force Close will be prevented from closing when force is false and\n\t     *  ‘close-requested’ has been subscribed to for application’s main window.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function closeApp() {\n\t     *     const allApps1 = await fin.System.getAllApplications(); //[{uuid: 'app1', isRunning: true}, {uuid: 'app2', isRunning: true}]\n\t     *     const app = await fin.Application.wrap({uuid: 'app2'});\n\t     *     await app.quit();\n\t     *     const allApps2 = await fin.System.getAllApplications(); //[{uuid: 'app1', isRunning: true}]\n\t     *\n\t     * }\n\t     * closeApp().then(() => console.log('Application quit')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    async quit(force = false) {\n\t        try {\n\t            await this._close(force);\n\t            await this.wire.sendAction('destroy-application', { force, ...this.identity });\n\t        }\n\t        catch (error) {\n\t            const acceptableErrors = ['Remote connection has closed', 'Could not locate the requested application'];\n\t            if (!acceptableErrors.some((msg) => error.message.includes(msg))) {\n\t                throw error;\n\t            }\n\t        }\n\t    }\n\t    async _close(force = false) {\n\t        try {\n\t            await this.wire.sendAction('close-application', { force, ...this.identity });\n\t        }\n\t        catch (error) {\n\t            if (!error.message.includes('Remote connection has closed')) {\n\t                throw error;\n\t            }\n\t        }\n\t    }\n\t    /**\n\t     * @deprecated use Application.quit instead\n\t     * Closes the application and any child windows created by the application.\n\t     * @param force - Close will be prevented from closing when force is false and ‘close-requested’ has been subscribed to for application’s main window.\n\t     * @param callback - called if the method succeeds.\n\t     * @param errorCallback - called if the method fails. The reason for failure is passed as an argument.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function closeApp() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.close();\n\t     * }\n\t     * closeApp().then(() => console.log('Application closed')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    close(force = false) {\n\t        console.warn('Deprecation Warning: Application.close is deprecated Please use Application.quit');\n\t        this.wire.sendAction('application-close', this.identity).catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return this._close(force);\n\t    }\n\t    /**\n\t     * Retrieves an array of wrapped fin.Windows for each of the application’s child windows.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function getChildWindows() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.getChildWindows();\n\t     * }\n\t     *\n\t     * getChildWindows().then(children => console.log(children)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getChildWindows() {\n\t        return this.wire.sendAction('get-child-windows', this.identity).then(({ payload }) => {\n\t            const identityList = [];\n\t            payload.data.forEach((winName) => {\n\t                identityList.push({ uuid: this.identity.uuid, name: winName });\n\t            });\n\t            return this.windowListFromIdentityList(identityList);\n\t        });\n\t    }\n\t    /**\n\t     * Retrieves the JSON manifest that was used to create the application. Invokes the error callback\n\t     * if the application was not created from a manifest.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function getManifest() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.getManifest();\n\t     * }\n\t     *\n\t     * getManifest().then(manifest => console.log(manifest)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getManifest() {\n\t        return this.wire.sendAction('get-application-manifest', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Retrieves UUID of the application that launches this application. Invokes the error callback\n\t     * if the application was created from a manifest.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function getParentUuid() {\n\t     *     const app = await fin.Application.start({\n\t     *         uuid: 'app-1',\n\t     *         name: 'myApp',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Application.getParentUuid.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getParentUuid();\n\t     * }\n\t     *\n\t     * getParentUuid().then(parentUuid => console.log(parentUuid)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getParentUuid() {\n\t        return this.wire.sendAction('get-parent-application', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Retrieves current application's shortcut configuration.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function getShortcuts() {\n\t     *     const app = await fin.Application.wrap({ uuid: 'testapp' });\n\t     *     return await app.getShortcuts();\n\t     * }\n\t     * getShortcuts().then(config => console.log(config)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getShortcuts() {\n\t        return this.wire.sendAction('get-shortcuts', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Retrieves current application's views.\n\t     * @experimental\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function getViews() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.getViews();\n\t     * }\n\t     * getViews().then(views => console.log(views)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    async getViews() {\n\t        const { payload } = await this.wire.sendAction('application-get-views', this.identity);\n\t        return payload.data.map((id) => new view_1.View(this.wire, id));\n\t    }\n\t    /**\n\t     * Returns the current zoom level of the application.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function getZoomLevel() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.getZoomLevel();\n\t     * }\n\t     *\n\t     * getZoomLevel().then(zoomLevel => console.log(zoomLevel)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getZoomLevel() {\n\t        return this.wire.sendAction('get-application-zoom-level', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Returns an instance of the main Window of the application\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function getWindow() {\n\t     *     const app = await fin.Application.start({\n\t     *         uuid: 'app-1',\n\t     *         name: 'myApp',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Application.getWindow.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     *\n\t     * getWindow().then(win => {\n\t     *     win.showAt(0, 400);\n\t     *     win.flash();\n\t     * }).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getWindow() {\n\t        this.wire.sendAction('application-get-window', this.identity).catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return Promise.resolve(this.window);\n\t    }\n\t    /**\n\t     * Manually registers a user with the licensing service. The only data sent by this call is userName and appName.\n\t     * @param userName - username to be passed to the RVM.\n\t     * @param appName - app name to be passed to the RVM.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function registerUser() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.registerUser('user', 'myApp');\n\t     * }\n\t     *\n\t     * registerUser().then(() => console.log('Successfully registered the user')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    registerUser(userName, appName) {\n\t        return this.wire.sendAction('register-user', { userName, appName, ...this.identity }).then(() => undefined);\n\t    }\n\t    /**\n\t     * Removes the application’s icon from the tray.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function removeTrayIcon() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.removeTrayIcon();\n\t     * }\n\t     *\n\t     * removeTrayIcon().then(() => console.log('Removed the tray icon.')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    removeTrayIcon() {\n\t        return this.wire.sendAction('remove-tray-icon', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Restarts the application.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function restartApp() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.restart();\n\t     * }\n\t     * restartApp().then(() => console.log('Application restarted')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    restart() {\n\t        return this.wire.sendAction('restart-application', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * DEPRECATED method to run the application.\n\t     * Needed when starting application via {@link Application.create}, but NOT needed when starting via {@link Application.start}.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function run() {\n\t     *     const app = await fin.Application.create({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Application.run.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     await app.run();\n\t     * }\n\t     * run().then(() => console.log('Application is running')).catch(err => console.log(err));\n\t     * ```\n\t     *\n\t     * @ignore\n\t     */\n\t    run() {\n\t        console.warn('Deprecation Warning: Application.run is deprecated Please use fin.Application.start');\n\t        this.wire.sendAction('application-run', this.identity).catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return this._run();\n\t    }\n\t    _run(opts = {}) {\n\t        return this.wire\n\t            .sendAction('run-application', {\n\t            manifestUrl: this._manifestUrl,\n\t            opts,\n\t            ...this.identity\n\t        })\n\t            .then(() => undefined);\n\t    }\n\t    /**\n\t     * Instructs the RVM to schedule one restart of the application.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function scheduleRestart() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.scheduleRestart();\n\t     * }\n\t     *\n\t     * scheduleRestart().then(() => console.log('Application is scheduled to restart')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    scheduleRestart() {\n\t        return this.wire.sendAction('relaunch-on-close', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Sends a message to the RVM to upload the application's logs. On success,\n\t     * an object containing logId is returned.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function sendLog() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.sendApplicationLog();\n\t     * }\n\t     *\n\t     * sendLog().then(info => console.log(info.logId)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    async sendApplicationLog() {\n\t        const { payload } = await this.wire.sendAction('send-application-log', this.identity);\n\t        return payload.data;\n\t    }\n\t    /**\n\t     * Sets or removes a custom JumpList for the application. Only applicable in Windows OS.\n\t     * If categories is null the previously set custom JumpList (if any) will be replaced by the standard JumpList for the app (managed by Windows).\n\t     *\n\t     * Note: If the \"name\" property is omitted it defaults to \"tasks\".\n\t     * @param jumpListCategories An array of JumpList Categories to populate. If null, remove any existing JumpList configuration and set to Windows default.\n\t     *\n\t     *\n\t     * @remarks If categories is null the previously set custom JumpList (if any) will be replaced by the standard JumpList for the app (managed by Windows).\n\t     *\n\t     * The bottommost item in the jumplist will always be an item pointing to the current app. Its name is taken from the manifest's\n\t     * **` shortcut.name `** and uses **` shortcut.company `** as a fallback. Clicking that item will launch the app from its current manifest.\n\t     *\n\t     * Note: If the \"name\" property is omitted it defaults to \"tasks\".\n\t     *\n\t     * Note: Window OS caches jumplists icons, therefore an icon change might only be visible after the cache is removed or the\n\t     * uuid or shortcut.name is changed.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     *     const app = fin.Application.getCurrentSync();\n\t     *     const appName = 'My App';\n\t     *     const jumpListConfig = [ // array of JumpList categories\n\t     *         {\n\t     *             // has no name and no type so `type` is assumed to be \"tasks\"\n\t     *             items: [ // array of JumpList items\n\t     *             {\n\t     *                 type: 'task',\n\t     *                 title: `Launch ${appName}`,\n\t     *                 description: `Runs ${appName} with the default configuration`,\n\t     *                 deepLink: 'fins://path.to/app/manifest.json',\n\t     *                 iconPath: 'https://path.to/app/icon.ico',\n\t     *                 iconIndex: 0\n\t     *             },\n\t     *             { type: 'separator' },\n\t     *             {\n\t     *                 type: 'task',\n\t     *                 title: `Restore ${appName}`,\n\t     *                 description: 'Restore to last configuration',\n\t     *                 deepLink: 'fins://path.to/app/manifest.json?$$use-last-configuration=true',\n\t     *                 iconPath: 'https://path.to/app/icon.ico',\n\t     *                 iconIndex: 0\n\t     *             },\n\t     *             ]\n\t     *         },\n\t     *         {\n\t     *             name: 'Tools',\n\t     *             items: [ // array of JumpList items\n\t     *             {\n\t     *                 type: 'task',\n\t     *                 title: 'Tool A',\n\t     *                 description: 'Runs Tool A',\n\t     *                 deepLink: 'fins://path.to/tool-a/manifest.json',\n\t     *                 iconPath: 'https://path.to/tool-a/icon.ico',\n\t     *                 iconIndex: 0\n\t     *             },\n\t     *             {\n\t     *                 type: 'task',\n\t     *                 title: 'Tool B',\n\t     *                 description: 'Runs Tool B',\n\t     *                 deepLink: 'fins://path.to/tool-b/manifest.json',\n\t     *                 iconPath: 'https://path.to/tool-b/icon.ico',\n\t     *                 iconIndex: 0\n\t     *             }]\n\t     *         }\n\t     *     ];\n\t     *\n\t     *     app.setJumpList(jumpListConfig).then(() => console.log('JumpList applied')).catch(e => console.log(`JumpList failed to apply: ${e.toString()}`));\n\t     * ```\n\t     *\n\t     * To handle deeplink args:\n\t     * ```js\n\t     *     function handleUseLastConfiguration() {\n\t     *         // this handler is called when the app is being launched\n\t     *         app.on('run-requested', event => {\n\t     *             if(event.userAppConfigArgs['use-last-configuration']) {\n\t     *                 // your logic here\n\t     *             }\n\t     *         });\n\t     *         // this handler is called when the app was already running when the launch was requested\n\t     *         fin.desktop.main(function(args) {\n\t     *             if(args && args['use-last-configuration']) {\n\t     *                 // your logic here\n\t     *             }\n\t     *         });\n\t     *     }\n\t     * ```\n\t     */\n\t    async setJumpList(jumpListCategories) {\n\t        await this.wire.sendAction('set-jump-list', { config: jumpListCategories, ...this.identity });\n\t    }\n\t    /**\n\t     * Adds a customizable icon in the system tray.  To listen for a click on the icon use the `tray-icon-clicked` event.\n\t     * @param icon Image URL or base64 encoded string to be used as the icon\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * const imageUrl = \"http://cdn.openfin.co/assets/testing/icons/circled-digit-one.png\";\n\t     * const base64EncodedImage = \"iVBORw0KGgoAAAANSUhEUgAAAAgAAAAIAQMAAAD+wSzIAAAABlBMVEX\\\n\t     * ///+/v7+jQ3Y5AAAADklEQVQI12P4AIX8EAgALgAD/aNpbtEAAAAASUVORK5CYII\";\n\t     * const dataURL = \"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DH\\\n\t     * xgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg==\";\n\t     *\n\t     * async function setTrayIcon(icon) {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.setTrayIcon(icon);\n\t     * }\n\t     *\n\t     * // use image url to set tray icon\n\t     * setTrayIcon(imageUrl).then(() => console.log('Setting tray icon')).catch(err => console.log(err));\n\t     *\n\t     * // use base64 encoded string to set tray icon\n\t     * setTrayIcon(base64EncodedImage).then(() => console.log('Setting tray icon')).catch(err => console.log(err));\n\t     *\n\t     * // use a dataURL to set tray icon\n\t     * setTrayIcon(dataURL).then(() => console.log('Setting tray icon')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    setTrayIcon(icon) {\n\t        return this.wire\n\t            .sendAction('set-tray-icon', {\n\t            enabledIcon: icon,\n\t            ...this.identity\n\t        })\n\t            .then(() => undefined);\n\t    }\n\t    /**\n\t     * Sets new application's shortcut configuration. Windows only.\n\t     * @param config New application's shortcut configuration.\n\t     *\n\t     * @remarks Application has to be launched with a manifest and has to have shortcut configuration (icon url, name, etc.) in its manifest\n\t     * to be able to change shortcut states.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function setShortcuts(config) {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return app.setShortcuts(config);\n\t     * }\n\t     *\n\t     * setShortcuts({\n\t     *     desktop: true,\n\t     *     startMenu: false,\n\t     *     systemStartup: true\n\t     * }).then(() => console.log('Shortcuts are set.')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    setShortcuts(config) {\n\t        return this.wire.sendAction('set-shortcuts', { data: config, ...this.identity }).then(() => undefined);\n\t    }\n\t    /**\n\t     * Sets the query string in all shortcuts for this app. Requires RVM 5.5+.\n\t     * @param queryString The new query string for this app's shortcuts.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * const newQueryArgs = 'arg=true&arg2=false';\n\t     * const app = await fin.Application.getCurrent();\n\t     * try {\n\t     *     await app.setShortcutQueryParams(newQueryArgs);\n\t     * } catch(err) {\n\t     *     console.error(err)\n\t     * }\n\t     * ```\n\t     */\n\t    async setShortcutQueryParams(queryString) {\n\t        await this.wire.sendAction('set-shortcut-query-args', { data: queryString, ...this.identity });\n\t    }\n\t    /**\n\t     * Sets the zoom level of the application. The original size is 0 and each increment above or below represents zooming 20%\n\t     * larger or smaller to default limits of 300% and 50% of original size, respectively.\n\t     * @param level The zoom level\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function setZoomLevel(number) {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.setZoomLevel(number);\n\t     * }\n\t     *\n\t     * setZoomLevel(5).then(() => console.log('Setting a  zoom level')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    setZoomLevel(level) {\n\t        return this.wire.sendAction('set-application-zoom-level', { level, ...this.identity }).then(() => undefined);\n\t    }\n\t    /**\n\t     * Sets a username to correlate with App Log Management.\n\t     * @param username Username to correlate with App's Log.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function setAppLogUser() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.setAppLogUsername('username');\n\t     * }\n\t     *\n\t     * setAppLogUser().then(() => console.log('Success')).catch(err => console.log(err));\n\t     *\n\t     * ```\n\t     */\n\t    async setAppLogUsername(username) {\n\t        await this.wire.sendAction('set-app-log-username', { data: username, ...this.identity });\n\t    }\n\t    /**\n\t     * Retrieves information about the system tray. If the system tray is not set, it will throw an error message.\n\t     * @remarks The only information currently returned is the position and dimensions.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function getTrayIconInfo() {\n\t     *     const app = await fin.Application.wrap({ uuid: 'testapp' });\n\t     *     return await app.getTrayIconInfo();\n\t     * }\n\t     * getTrayIconInfo().then(info => console.log(info)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getTrayIconInfo() {\n\t        return this.wire.sendAction('get-tray-icon-info', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Checks if the application has an associated tray icon.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * const app = await fin.Application.wrap({ uuid: 'testapp' });\n\t     * const hasTrayIcon = await app.hasTrayIcon();\n\t     * console.log(hasTrayIcon);\n\t     * ```\n\t     */\n\t    hasTrayIcon() {\n\t        return this.wire.sendAction('has-tray-icon', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Closes the application by terminating its process.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function terminateApp() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.terminate();\n\t     * }\n\t     * terminateApp().then(() => console.log('Application terminated')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    terminate() {\n\t        return this.wire.sendAction('terminate-application', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Waits for a hanging application. This method can be called in response to an application\n\t     * \"not-responding\" to allow the application to continue and to generate another \"not-responding\"\n\t     * message after a certain period of time.\n\t     *\n\t     * @ignore\n\t     */\n\t    wait() {\n\t        return this.wire.sendAction('wait-for-hung-application', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Retrieves information about the application.\n\t     *\n\t     * @remarks If the application was not launched from a manifest, the call will return the closest parent application `manifest`\n\t     * and `manifestUrl`.  `initialOptions` shows the parameters used when launched programmatically, or the `startup_app` options\n\t     * if launched from manifest. The `parentUuid` will be the uuid of the immediate parent (if applicable).\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function getInfo() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.getInfo();\n\t     * }\n\t     *\n\t     * getInfo().then(info => console.log(info)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getInfo() {\n\t        return this.wire.sendAction('get-info', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Retrieves all process information for entities (windows and views) associated with an application.\n\t     *\n\t     * @example\n\t     * ```js\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     const processInfo = await app.getProcessInfo();\n\t     * ```\n\t     * @experimental\n\t     */\n\t    async getProcessInfo() {\n\t        const { payload: { data } } = await this.wire.sendAction('application-get-process-info', this.identity);\n\t        return data;\n\t    }\n\t    /**\n\t     * Sets file auto download location. It's only allowed in the same application.\n\t     *\n\t     * Note: This method is restricted by default and must be enabled via\n\t     * <a href=\"https://developers.openfin.co/docs/api-security\">API security settings</a>.\n\t     * @param downloadLocation file auto download location\n\t     *\n\t     * @throws if setting file auto download location on different applications.\n\t     * @example\n\t     *\n\t     * ```js\n\t     * const downloadLocation = 'C:\\\\dev\\\\temp';\n\t     * const app = await fin.Application.getCurrent();\n\t     * try {\n\t     *     await app.setFileDownloadLocation(downloadLocation);\n\t     *     console.log('File download location is set');\n\t     * } catch(err) {\n\t     *     console.error(err)\n\t     * }\n\t     * ```\n\t     */\n\t    async setFileDownloadLocation(downloadLocation) {\n\t        const { name } = this.wire.me;\n\t        const entityIdentity = { uuid: this.identity.uuid, name };\n\t        await this.wire.sendAction('set-file-download-location', { ...entityIdentity, downloadLocation });\n\t    }\n\t    /**\n\t     * Gets file auto download location. It's only allowed in the same application. If file auto download location is not set, it will return the default location.\n\t     *\n\t     * Note: This method is restricted by default and must be enabled via\n\t     * <a href=\"https://developers.openfin.co/docs/api-security\">API security settings</a>.\n\t     *\n\t     * @throws if getting file auto download location on different applications.\n\t     * @example\n\t     *\n\t     * ```js\n\t     * const app = await fin.Application.getCurrent();\n\t     * const fileDownloadDir =  await app.getFileDownloadLocation();\n\t     * ```\n\t     */\n\t    async getFileDownloadLocation() {\n\t        const { payload: { data } } = await this.wire.sendAction('get-file-download-location', this.identity);\n\t        return data;\n\t    }\n\t    /**\n\t     * Shows a menu on the tray icon. Use with tray-icon-clicked event.\n\t     * @param options\n\t     * @typeParam Data User-defined shape for data returned upon menu item click. Should be a\n\t     * [union](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#union-types)\n\t     * of all possible data shapes for the entire menu, and the click handler should process\n\t     * these with a \"reducer\" pattern.\n\t     * @throws if the application has no tray icon set\n\t     * @throws if the system tray is currently hidden\n\t     * @example\n\t     *\n\t     * ```js\n\t     * const iconUrl = 'http://cdn.openfin.co/assets/testing/icons/circled-digit-one.png';\n\t     * const app = fin.Application.getCurrentSync();\n\t     *\n\t     * await app.setTrayIcon(iconUrl);\n\t     *\n\t     * const template = [\n\t     *  {\n\t     *    label: 'Menu Item 1',\n\t     *    data: 'hello from item 1'\n\t     *  },\n\t     *  { type: 'separator' },\n\t     *  {\n\t     *    label: 'Menu Item 2',\n\t     *    type: 'checkbox',\n\t     *    checked: true,\n\t     *    data: 'The user clicked the checkbox'\n\t     *  },\n\t     *  {\n\t     *    label: 'see more',\n\t     *    enabled: false,\n\t     *    submenu: [\n\t     *      { label: 'submenu 1', data: 'hello from submenu' }\n\t     *    ]\n\t     *  }\n\t     * ];\n\t     *\n\t     * app.addListener('tray-icon-clicked', (event) => {\n\t     *   // right-click\n\t     *   if (event.button === 2) {\n\t     *     app.showTrayIconPopupMenu({ template }).then(r => {\n\t     *       if (r.result === 'closed') {\n\t     *         console.log('nothing happened');\n\t     *       } else {\n\t     *         console.log(r.data);\n\t     *       }\n\t     *     });\n\t     *   }\n\t     * });\n\t     * ```\n\t     */\n\t    async showTrayIconPopupMenu(options) {\n\t        const { name } = this.wire.me;\n\t        const entityIdentity = { uuid: this.identity.uuid, name };\n\t        const { payload } = await this.wire.sendAction('show-tray-icon-popup-menu', { ...entityIdentity, options });\n\t        return payload.data;\n\t    }\n\t    /**\n\t     * Closes the tray icon menu.\n\t     *\n\t     * @throws if the application has no tray icon set\n\t     * @example\n\t     *\n\t     * ```js\n\t     * const app = fin.Application.getCurrentSync();\n\t     *\n\t     * await app.closeTrayIconPopupMenu();\n\t     * ```\n\t     */\n\t    async closeTrayIconPopupMenu() {\n\t        const { name } = this.wire.me;\n\t        const entityIdentity = { uuid: this.identity.uuid, name };\n\t        await this.wire.sendAction('close-tray-icon-popup-menu', { ...entityIdentity });\n\t    }\n\t}\n\tInstance$6.Application = Application;\n\treturn Instance$6;\n}\n\nvar hasRequiredFactory$2;\n\nfunction requireFactory$2 () {\n\tif (hasRequiredFactory$2) return Factory$7;\n\thasRequiredFactory$2 = 1;\n\tObject.defineProperty(Factory$7, \"__esModule\", { value: true });\n\tFactory$7.ApplicationModule = void 0;\n\tconst base_1 = base;\n\tconst validate_1 = validate;\n\tconst Instance_1 = requireInstance$1();\n\t/**\n\t * Static namespace for OpenFin API methods that interact with the {@link Application} class, available under `fin.Application`.\n\t */\n\tclass ApplicationModule extends base_1.Base {\n\t    /**\n\t     * Asynchronously returns an API handle for the given Application identity.\n\t     *\n\t     * @remarks Wrapping an Application identity that does not yet exist will *not* throw an error, and instead\n\t     * returns a stub object that cannot yet perform rendering tasks. This can be useful for plumbing eventing\n\t     * for an Application throughout its entire lifecycle.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * fin.Application.wrap({ uuid: 'testapp' })\n\t     * .then(app => app.isRunning())\n\t     * .then(running => console.log('Application is running: ' + running))\n\t     * .catch(err => console.log(err));\n\t     * ```\n\t     *\n\t     */\n\t    async wrap(identity) {\n\t        this.wire.sendAction('wrap-application').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const errorMsg = (0, validate_1.validateIdentity)(identity);\n\t        if (errorMsg) {\n\t            throw new Error(errorMsg);\n\t        }\n\t        return new Instance_1.Application(this.wire, identity);\n\t    }\n\t    /**\n\t     * Synchronously returns an API handle for the given Application identity.\n\t     *\n\t     * @remarks Wrapping an Application identity that does not yet exist will *not* throw an error, and instead\n\t     * returns a stub object that cannot yet perform rendering tasks. This can be useful for plumbing eventing\n\t     * for an Aplication throughout its entire lifecycle.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * const app = fin.Application.wrapSync({ uuid: 'testapp' });\n\t     * await app.close();\n\t     * ```\n\t     *\n\t     */\n\t    wrapSync(identity) {\n\t        this.wire.sendAction('wrap-application-sync').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const errorMsg = (0, validate_1.validateIdentity)(identity);\n\t        if (errorMsg) {\n\t            throw new Error(errorMsg);\n\t        }\n\t        return new Instance_1.Application(this.wire, identity);\n\t    }\n\t    async _create(appOptions) {\n\t        // set defaults:\n\t        if (appOptions.waitForPageLoad === undefined) {\n\t            appOptions.waitForPageLoad = false;\n\t        }\n\t        if (appOptions.autoShow === undefined && appOptions.isPlatformController === undefined) {\n\t            appOptions.autoShow = true;\n\t        }\n\t        await this.wire.sendAction('create-application', appOptions);\n\t        return this.wrap({ uuid: appOptions.uuid });\n\t    }\n\t    /**\n\t     * DEPRECATED method to create a new Application. Use {@link Application.ApplicationModule.start Application.start} instead.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function createApp() {\n\t     *     const app = await fin.Application.create({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-3',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Application.create.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     await app.run();\n\t     * }\n\t     *\n\t     * createApp().then(() => console.log('Application is created')).catch(err => console.log(err));\n\t     * ```\n\t     *\n\t     * @ignore\n\t     */\n\t    create(appOptions) {\n\t        console.warn('Deprecation Warning: fin.Application.create is deprecated. Please use fin.Application.start');\n\t        this.wire.sendAction('application-create').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return this._create(appOptions);\n\t    }\n\t    /**\n\t     * Creates and starts a new Application.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function start() {\n\t     *     return fin.Application.start({\n\t     *         name: 'app-1',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Application.start.html',\n\t     *         autoShow: true\n\t     *     });\n\t     * }\n\t     * start().then(() => console.log('Application is running')).catch(err => console.log(err));\n\t     * ```\n\t     *\n\t     */\n\t    async start(appOptions) {\n\t        this.wire.sendAction('start-application').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const app = await this._create(appOptions);\n\t        await this.wire.sendAction('run-application', { uuid: appOptions.uuid });\n\t        return app;\n\t    }\n\t    /**\n\t     * Asynchronously starts a batch of applications given an array of application identifiers and manifestUrls.\n\t     * Returns once the RVM is finished attempting to launch the applications.\n\t     * @param opts - Parameters that the RVM will use.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     *\n\t     * const applicationInfoArray = [\n\t     *     {\n\t     *         \"uuid\": 'App-1',\n\t     *         \"manifestUrl\": 'http://localhost:5555/app1.json',\n\t     *     },\n\t     *     {\n\t     *         \"uuid\": 'App-2',\n\t     *         \"manifestUrl\": 'http://localhost:5555/app2.json',\n\t     *     },\n\t     *     {\n\t     *         \"uuid\": 'App-3',\n\t     *         \"manifestUrl\": 'http://localhost:5555/app3.json',\n\t     *     }\n\t     * ]\n\t     *\n\t     * fin.Application.startManyManifests(applicationInfoArray)\n\t     *     .then(() => {\n\t     *         console.log('RVM has finished launching the application list.');\n\t     *     })\n\t     *     .catch((err) => {\n\t     *         console.log(err);\n\t     *     })\n\t     * ```\n\t     *\n\t     * @experimental\n\t     */\n\t    async startManyManifests(applications, opts) {\n\t        return this.wire.sendAction('run-applications', { applications, opts }).then(() => undefined);\n\t    }\n\t    /**\n\t     * Asynchronously returns an Application object that represents the current application\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function isCurrentAppRunning () {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return app.isRunning();\n\t     * }\n\t     *\n\t     * isCurrentAppRunning().then(running => {\n\t     *     console.log(`Current app is running: ${running}`);\n\t     * }).catch(err => {\n\t     *     console.error(err);\n\t     * });\n\t     *\n\t     * ```\n\t     */\n\t    getCurrent() {\n\t        this.wire.sendAction('get-current-application').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return this.wrap({ uuid: this.wire.me.uuid });\n\t    }\n\t    /**\n\t     * Synchronously returns an Application object that represents the current application\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function isCurrentAppRunning () {\n\t     *     const app = fin.Application.getCurrentSync();\n\t     *     return app.isRunning();\n\t     * }\n\t     *\n\t     * isCurrentAppRunning().then(running => {\n\t     *     console.log(`Current app is running: ${running}`);\n\t     * }).catch(err => {\n\t     *     console.error(err);\n\t     * });\n\t     *\n\t     * ```\n\t     */\n\t    getCurrentSync() {\n\t        this.wire.sendAction('get-current-application-sync').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return this.wrapSync({ uuid: this.wire.me.uuid });\n\t    }\n\t    /**\n\t     * Retrieves application's manifest and returns a running instance of the application.\n\t     * @param manifestUrl - The URL of app's manifest.\n\t     * @param opts - Parameters that the RVM will use.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * fin.Application.startFromManifest('http://localhost:5555/app.json').then(app => console.log('App is running')).catch(err => console.log(err));\n\t     *\n\t     * // For a local manifest file:\n\t     * fin.Application.startFromManifest('file:///C:/somefolder/app.json').then(app => console.log('App is running')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    async startFromManifest(manifestUrl, opts) {\n\t        this.wire.sendAction('application-start-from-manifest').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const app = await this._createFromManifest(manifestUrl);\n\t        // @ts-expect-error using private method without warning.\n\t        await app._run(opts); // eslint-disable-line no-underscore-dangle\n\t        return app;\n\t    }\n\t    /**\n\t     * @deprecated Use {@link Application.ApplicationModule.startFromManifest Application.startFromManifest} instead.\n\t     * Retrieves application's manifest and returns a wrapped application.\n\t     * @param manifestUrl - The URL of app's manifest.\n\t     * @param callback - called if the method succeeds.\n\t     * @param errorCallback - called if the method fails. The reason for failure is passed as an argument.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * fin.Application.createFromManifest('http://localhost:5555/app.json').then(app => console.log(app)).catch(err => console.log(err));\n\t     * ```\n\t     * @ignore\n\t     */\n\t    createFromManifest(manifestUrl) {\n\t        console.warn('Deprecation Warning: fin.Application.createFromManifest is deprecated. Please use fin.Application.startFromManifest');\n\t        this.wire.sendAction('application-create-from-manifest').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return this._createFromManifest(manifestUrl);\n\t    }\n\t    _createFromManifest(manifestUrl) {\n\t        return this.wire\n\t            .sendAction('get-application-manifest', { manifestUrl })\n\t            .then(({ payload }) => {\n\t            const uuid = payload.data.platform ? payload.data.platform.uuid : payload.data.startup_app.uuid;\n\t            return this.wrap({ uuid });\n\t        })\n\t            .then((app) => {\n\t            app._manifestUrl = manifestUrl; // eslint-disable-line no-underscore-dangle\n\t            return app;\n\t        });\n\t    }\n\t}\n\tFactory$7.ApplicationModule = ApplicationModule;\n\treturn Factory$7;\n}\n\nvar hasRequiredApplication;\n\nfunction requireApplication () {\n\tif (hasRequiredApplication) return application;\n\thasRequiredApplication = 1;\n\t(function (exports) {\n\t\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t\t    if (k2 === undefined) k2 = k;\n\t\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t\t    }\n\t\t    Object.defineProperty(o, k2, desc);\n\t\t}) : (function(o, m, k, k2) {\n\t\t    if (k2 === undefined) k2 = k;\n\t\t    o[k2] = m[k];\n\t\t}));\n\t\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t\t};\n\t\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t\t/**\n\t\t * Entry points for the OpenFin `Application` API (`fin.Application`).\n\t\t *\n\t\t * * {@link ApplicationModule} contains static members of the `Application` API, accessible through `fin.Application`.\n\t\t * * {@link Application} describes an instance of an OpenFin Application, e.g. as returned by `fin.Application.getCurrent`.\n\t\t *\n\t\t * These are separate code entities, and are documented separately.  In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/32.114.76.10/index.html),\n\t\t * both of these were documented on the same page.\n\t\t *\n\t\t * @packageDocumentation\n\t\t */\n\t\t__exportStar(requireFactory$2(), exports);\n\t\t__exportStar(requireInstance$1(), exports); \n\t} (application));\n\treturn application;\n}\n\nvar promisifySubscription$1 = {};\n\nObject.defineProperty(promisifySubscription$1, \"__esModule\", { value: true });\npromisifySubscription$1.promisifySubscription = void 0;\nconst promisifySubscription = async (emitter, eventName, predicate = () => true, timeout) => {\n    let resolve;\n    let reject;\n    let timer;\n    const valuePromise = new Promise((y, n) => {\n        resolve = y;\n        reject = n;\n    });\n    const listener = (e) => {\n        if (predicate(e)) {\n            clearTimeout(timer);\n            resolve(e);\n        }\n    };\n    await emitter.on(eventName, listener);\n    if (timeout) {\n        timer = setTimeout(() => reject(new Error('event timed out')), timeout);\n    }\n    valuePromise.finally(() => {\n        emitter.removeListener(eventName, listener).catch(() => null);\n    });\n    return {\n        getValue: () => valuePromise\n    };\n};\npromisifySubscription$1.promisifySubscription = promisifySubscription;\n\nvar hasRequiredInstance;\n\nfunction requireInstance () {\n\tif (hasRequiredInstance) return Instance$7;\n\thasRequiredInstance = 1;\n\tObject.defineProperty(Instance$7, \"__esModule\", { value: true });\n\tInstance$7._Window = void 0;\n\t/* eslint-disable import/prefer-default-export */\n\t/* eslint-disable @typescript-eslint/no-unused-vars */\n\t/* eslint-disable no-console */\n\t/* eslint-disable @typescript-eslint/no-non-null-assertion */\n\tconst application_1 = requireApplication();\n\tconst main_1 = main;\n\tconst view_1 = requireView();\n\tconst warnings_1 = warnings;\n\tconst promisifySubscription_1 = promisifySubscription$1;\n\t/**\n\t * A basic window that wraps a native HTML window. Provides more fine-grained\n\t * control over the window state such as the ability to minimize, maximize, restore, etc.\n\t * By default a window does not show upon instantiation; instead the window's show() method\n\t * must be invoked manually. The new window appears in the same process as the parent window.\n\t * It has the ability to listen for {@link OpenFin.WindowEvents window specific events}.\n\t */\n\t// The window.Window name is taken\n\tclass _Window extends main_1.WebContents {\n\t    /**\n\t     * @internal\n\t     */\n\t    constructor(wire, identity) {\n\t        super(wire, identity, 'window');\n\t    }\n\t    async createWindow(options) {\n\t        this.wire.sendAction('window-create-window', this.identity).catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const CONSTRUCTOR_CB_TOPIC = 'fire-constructor-callback';\n\t        const responseSubscription = await (0, promisifySubscription_1.promisifySubscription)(this, CONSTRUCTOR_CB_TOPIC);\n\t        // set defaults:\n\t        if (options.waitForPageLoad === undefined) {\n\t            options.waitForPageLoad = false;\n\t        }\n\t        if (options.autoShow === undefined) {\n\t            options.autoShow = true;\n\t        }\n\t        (0, warnings_1.handleDeprecatedWarnings)(options);\n\t        const windowCreation = this.wire.environment.createChildContent({ entityType: 'window', options });\n\t        const [response] = await Promise.all([responseSubscription.getValue(), windowCreation]);\n\t        let cbPayload;\n\t        const { success } = response;\n\t        const responseData = response.data;\n\t        const { message } = responseData;\n\t        if (success) {\n\t            cbPayload = {\n\t                httpResponseCode: responseData.httpResponseCode,\n\t                apiInjected: responseData.apiInjected\n\t            };\n\t        }\n\t        else {\n\t            cbPayload = {\n\t                message: responseData.message,\n\t                networkErrorCode: responseData.networkErrorCode,\n\t                stack: responseData.stack\n\t            };\n\t        }\n\t        const pageResolve = {\n\t            message,\n\t            cbPayload,\n\t            success\n\t        };\n\t        try {\n\t            // this is to enforce a 5.0 contract that the child's main function\n\t            // will not fire before the parent's success callback on creation.\n\t            // if the child window is not accessible (CORS) this contract does\n\t            // not hold.\n\t            const webWindow = this.getWebWindow();\n\t            webWindow.fin.__internal_.openerSuccessCBCalled();\n\t        }\n\t        catch (e) {\n\t            // common for main windows, we do not want to expose this error. here just to have a debug target.\n\t            // console.error(e);\n\t        }\n\t        if (pageResolve.success) {\n\t            return this;\n\t        }\n\t        return Promise.reject(pageResolve);\n\t    }\n\t    /**\n\t     * Retrieves an array of frame info objects representing the main frame and any\n\t     * iframes that are currently on the page.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function getAllFrames() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getAllFrames.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.getAllFrames();\n\t     * }\n\t     *\n\t     * getAllFrames().then(framesInfo => console.log(framesInfo)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getAllFrames() {\n\t        return this.wire.sendAction('get-all-frames', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Gets the current bounds (top, bottom, right, left, width, height) of the window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function getBounds() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-3',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getBounds.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.getBounds();\n\t     * }\n\t     *\n\t     * getBounds().then(bounds => console.log(bounds)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getBounds() {\n\t        return this.wire\n\t            .sendAction('get-window-bounds', this.identity)\n\t            .then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Centers the window on its current screen.\n\t     *\n\t     * @remarks Does not have an effect on minimized or maximized windows.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function centerWindow() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.center.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.center();\n\t     * }\n\t     *\n\t     * centerWindow().then(() => console.log('Window centered')).catch(err => console.log(err));\n\t     * ```\n\t     *\n\t     */\n\t    center() {\n\t        return this.wire.sendAction('center-window', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Removes focus from the window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function blurWindow() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.blur.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.blur();\n\t     * }\n\t     *\n\t     * blurWindow().then(() => console.log('Blured Window')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    blur() {\n\t        return this.wire.sendAction('blur-window', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Brings the window to the front of the window stack.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function BringWindowToFront() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.bringToFront.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.bringToFront();\n\t     * }\n\t     *\n\t     * BringWindowToFront().then(() => console.log('Window is in the front')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    bringToFront() {\n\t        return this.wire.sendAction('bring-window-to-front', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Performs the specified window transitions.\n\t     * @param transitions - Describes the animations to perform. See the tutorial.\n\t     * @param options - Options for the animation. See the tutorial.\n\t     *\n\t     * @example\n\t     * ```\n\t     * async function animateWindow() {\n\t     *     const transitions = {\n\t     *         opacity: {\n\t     *             opacity: 0.7,\n\t     *             duration: 500\n\t     *         },\n\t     *         position: {\n\t     *             top: 100,\n\t     *             left: 100,\n\t     *             duration: 500,\n\t     *             relative: true\n\t     *         }\n\t     *     };\n\t     *     const options = {\n\t     *         interrupt: true,\n\t     *         tween: 'ease-in'\n\t     *     };\n\t     *\n\t     *     const win = await fin.Window.getCurrent();\n\t     *     return win.animate(transitions, options);\n\t     * }\n\t     *\n\t     * animateWindow()\n\t     *     .then(() => console.log('Animation done'))\n\t     *     .catch(err => console.error(err));\n\t     * ```\n\t     */\n\t    animate(transitions, options) {\n\t        return this.wire\n\t            .sendAction('animate-window', {\n\t            transitions,\n\t            options,\n\t            ...this.identity\n\t        })\n\t            .then(() => undefined);\n\t    }\n\t    /**\n\t     * Hides the window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function hideWindow() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.hide.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.hide();\n\t     * }\n\t     *\n\t     * hideWindow().then(() => console.log('Window is hidden')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    hide() {\n\t        return this.wire.sendAction('hide-window', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * closes the window application\n\t     * @param force Close will be prevented from closing when force is false and\n\t     *  ‘close-requested’ has been subscribed to for application’s main window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function closeWindow() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-3',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.close.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.close();\n\t     * }\n\t     *\n\t     * closeWindow().then(() => console.log('Window closed')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    close(force = false) {\n\t        return this.wire.sendAction('close-window', { force, ...this.identity }).then(() => {\n\t            Object.setPrototypeOf(this, null);\n\t            return undefined;\n\t        });\n\t    }\n\t    focusedWebViewWasChanged() {\n\t        return this.wire.sendAction('focused-webview-changed', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Returns the native OS level Id.\n\t     *\n\t     * @remarks In Windows, it will return the Windows [handle](https://docs.microsoft.com/en-us/windows/desktop/WinProg/windows-data-types#HWND).\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function getWindowNativeId() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-3',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getNativeId.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.getNativeId();\n\t     * }\n\t     *\n\t     * getWindowNativeId().then(nativeId => console.log(nativeId)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getNativeId() {\n\t        return this.wire.sendAction('get-window-native-id', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Retrieves window's attached views.\n\t     * @experimental\n\t     *\n\t     * @example\n\t     * ```js\n\t     * const win = fin.Window.getCurrentSync();\n\t     *\n\t     * win.getCurrentViews()\n\t     *   .then(views => console.log(views))\n\t     *   .catch(console.error);\n\t     * ```\n\t     */\n\t    async getCurrentViews() {\n\t        const { payload } = await this.wire.sendAction('window-get-views', this.identity);\n\t        return payload.data.map((id) => new view_1.View(this.wire, id));\n\t    }\n\t    /**\n\t     * @deprecated Use {@link Window._Window.disableUserMovement} instead.\n\t     */\n\t    disableFrame() {\n\t        console.warn('Function is deprecated; use disableUserMovement instead.');\n\t        return this.wire.sendAction('disable-window-frame', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Prevents a user from changing a window's size/position when using the window's frame.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function disableUserMovement() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-3',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.disableFrame.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.disableUserMovement();\n\t     * }\n\t     *\n\t     * disableUserMovement().then(() => console.log('Window is disabled')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    disableUserMovement() {\n\t        return this.wire.sendAction('disable-window-frame', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * @deprecated Use {@link Window._Window.enableUserMovement} instead.\n\t     */\n\t    enableFrame() {\n\t        console.warn('Function is deprecated; use enableUserMovement instead.');\n\t        return this.wire.sendAction('enable-window-frame', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Re-enables user changes to a window's size/position when using the window's frame.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function enableUserMovement() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-3',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.enableFrame.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.enableUserMovement();\n\t     * }\n\t     *\n\t     * enableUserMovement().then(() => console.log('Window is enabled')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    enableUserMovement() {\n\t        return this.wire.sendAction('enable-window-frame', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Flashes the window’s frame and taskbar icon until stopFlashing is called or until a focus event is fired.\n\t     *\n\t     * @remarks On macOS flash only works on inactive windows.\n\t     * @example\n\t     * ```js\n\t     * async function windowFlash() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.flash.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.flash();\n\t     * }\n\t     *\n\t     * windowFlash().then(() => console.log('Window flashing')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    flash() {\n\t        return this.wire.sendAction('flash-window', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Stops the taskbar icon from flashing.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function stopWindowFlashing() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.stopFlashing.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.stopFlashing();\n\t     * }\n\t     *\n\t     * stopWindowFlashing().then(() => console.log('Application window flashing')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    stopFlashing() {\n\t        return this.wire.sendAction('stop-flash-window', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Gets an information object for the window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function getInfo() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getInfo.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.getInfo();\n\t     * }\n\t     *\n\t     * getInfo().then(info => console.log(info)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getInfo() {\n\t        return this.wire.sendAction('get-window-info', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Retrieves the window's Layout\n\t     *\n\t     * @example\n\t     * ```js\n\t     *     //get the current window\n\t     *     const window = await fin.Window.getCurrent();\n\t     *\n\t     *     //get the layout for the window\n\t     *     const layout = await window.getLayout();\n\t     * ```\n\t     * @experimental\n\t     */\n\t    async getLayout(layoutIdentity) {\n\t        this.wire.sendAction('window-get-layout', this.identity).catch((e) => {\n\t            // don't expose\n\t        });\n\t        const opts = await this.getOptions();\n\t        if (!opts.layout && !opts.layoutSnapshot) {\n\t            throw new Error('Window does not have a Layout');\n\t        }\n\t        return this.fin.Platform.Layout.wrap(layoutIdentity ?? this.identity);\n\t    }\n\t    /**\n\t     * Gets the current settings of the window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function getWindowOptions() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getOptions.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.getOptions();\n\t     * }\n\t     *\n\t     * getWindowOptions().then(opts => console.log(opts)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getOptions() {\n\t        return this.wire.sendAction('get-window-options', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Gets the parent application.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function getParentApplication() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getParentApplication.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.getParentApplication();\n\t     * }\n\t     *\n\t     * getParentApplication().then(parentApplication => console.log(parentApplication)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getParentApplication() {\n\t        this.wire.sendAction('window-get-parent-application', this.identity).catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return Promise.resolve(new application_1.Application(this.wire, this.identity));\n\t    }\n\t    /**\n\t     * Gets the parent window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function getParentWindow() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getParentWindow.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.getParentWindow();\n\t     * }\n\t     *\n\t     * getParentWindow().then(parentWindow => console.log(parentWindow)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getParentWindow() {\n\t        this.wire.sendAction('window-get-parent-window', this.identity).catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return Promise.resolve(new application_1.Application(this.wire, this.identity)).then((app) => app.getWindow());\n\t    }\n\t    /**\n\t     * ***DEPRECATED - please use Window.capturePage.***\n\t     * Gets a base64 encoded PNG image of the window or just part a of it.\n\t     * @param area The area of the window to be captured.\n\t     * Omitting it will capture the whole visible window.\n\t     *\n\t     * @tutorial Window.capturePage\n\t     */\n\t    async getSnapshot(area) {\n\t        const req = { area, ...this.identity };\n\t        console.warn('Window.getSnapshot has been deprecated, please use Window.capturePage');\n\t        const res = await this.wire.sendAction('get-window-snapshot', req);\n\t        return res.payload.data;\n\t    }\n\t    /**\n\t     * Gets the current state (\"minimized\", \"maximized\", or \"normal\") of the window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function getWindowState() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getState.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.getState();\n\t     * }\n\t     *\n\t     * getWindowState().then(winState => console.log(winState)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getState() {\n\t        return this.wire.sendAction('get-window-state', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Previously called getNativeWindow.\n\t     * Returns the [Window Object](https://developer.mozilla.org/en-US/docs/Web/API/Window)\n\t     * that represents the web context of the target window. This is the same object that\n\t     * you would get from calling [window.open()](https://developer.mozilla.org/en-US/docs/Web/API/Window/open) in a standard web context.\n\t     * The target window needs to be in the same application as the requesting window\n\t     * as well as comply with [same-origin](https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy) policy requirements.\n\t     *\n\t     * @example\n\t     * Injecting content into an empty window:\n\t     *\n\t     * ```js\n\t     * (async ()=> {\n\t     *     try {\n\t     *         const winName = `child-window-${Date.now()}`;\n\t     *         const win = await fin.Window.create({\n\t     *             name: winName,\n\t     *             url: 'about:blank'\n\t     *         });\n\t     *         win.getWebWindow().document.write('<h1>Hello World</h1>');\n\t     *     } catch (err) {\n\t     *         console.error(err);\n\t     *     }\n\t     * })();\n\t     * ```\n\t     *\n\t     * Cloning DOM elements from the parent window (in this example we clone an `h3` element from the parent window):\n\t     * ```js\n\t     * (async ()=> {\n\t     *     try {\n\t     *         const currentWindow = await fin.Window.getCurrent();\n\t     *         const parentWindow = await currentWindow.getParentWindow();\n\t     *         const clonedH3 = parentWindow.getWebWindow().document.querySelector('h3').cloneNode(true);\n\t     *         document.body.append(clonedH3);\n\t     *\n\t     *     } catch (err) {\n\t     *         console.error(err);\n\t     *     }\n\t     * })();\n\t     * ```\n\t     *\n\t     * Rendering on a child window via a library (in this example we are using the [lit-html](https://lit-html.polymer-project.org/)\n\t     * template library to render content on a blank child window. You are not going to be able to copy paste this example without\n\t     * configuring the project correctly but this would demonstrate some templating options available):\n\t     * ```js\n\t     * (async ()=> {\n\t     *     try {\n\t     *         const win = await fin.Window.create({\n\t     *             name: `child-window-${Date.now()}`,\n\t     *             url: 'about:blank'\n\t     *         });\n\t     *         const template = html`\n\t     *             <div>\n\t     *                 <span>Click here: </span>\n\t     *                 <button @click=${()=> console.log('Hello World!')}>log to the console</button>\n\t     *             </div>`;\n\t     *         render(template, win.getWebWindow().document.body);\n\t     *\n\t     *     } catch (err) {\n\t     *         console.error(err);\n\t     *     }\n\t     * })();\n\t     * ```\n\t     */\n\t    getWebWindow() {\n\t        this.wire.sendAction('window-get-web-window', this.identity).catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return this.wire.environment.getWebWindow(this.identity);\n\t    }\n\t    /**\n\t     * Determines if the window is a main window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * const wnd = fin.Window.getCurrentSync();\n\t     * const isMainWnd = wnd.isMainWindow();\n\t     * console.log('Is this a main window? ' + isMainWnd);\n\t     * ```\n\t     */\n\t    isMainWindow() {\n\t        this.wire.sendAction('window-is-main-window', this.identity).catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return this.me.uuid === this.me.name;\n\t    }\n\t    /**\n\t     * Determines if the window is currently showing.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function isWindowShowing() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.isShowing.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.isShowing();\n\t     * }\n\t     *\n\t     * isWindowShowing().then(bool => console.log(bool)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    isShowing() {\n\t        return this.wire.sendAction('is-window-showing', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Maximizes the window\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function maxWindow() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.maximize.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.maximize();\n\t     * }\n\t     *\n\t     * maxWindow().then(() => console.log('Maximized window')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    maximize() {\n\t        return this.wire.sendAction('maximize-window', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Minimizes the window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function minWindow() {\n\t     *     const win = await fin.Window.getCurrent();\n\t     *     return await win.minimize();\n\t     * }\n\t     *\n\t     * minWindow().then(() => console.log('Minimized window')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    minimize() {\n\t        return this.wire.sendAction('minimize-window', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Moves the window by a specified amount.\n\t     * @param deltaLeft The change in the left position of the window\n\t     * @param deltaTop The change in the top position of the window\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWin() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.moveBy.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     *\n\t     * async function moveBy(left, top) {\n\t     *     const win = await createWin();\n\t     *     return await win.moveBy(left, top);\n\t     * }\n\t     *\n\t     * moveBy(580, 300).then(() => console.log('Moved')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    moveBy(deltaLeft, deltaTop, positioningOptions) {\n\t        return this.wire\n\t            .sendAction('move-window-by', {\n\t            deltaLeft,\n\t            deltaTop,\n\t            positioningOptions,\n\t            ...this.identity\n\t        })\n\t            .then(() => undefined);\n\t    }\n\t    /**\n\t     * Moves the window to a specified location.\n\t     * @param left The left position of the window\n\t     * @param top The top position of the window\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWin() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.moveTo.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     *\n\t     * async function moveTo(left, top) {\n\t     *     const win = await createWin();\n\t     *     return await win.moveTo(left, top)\n\t     * }\n\t     *\n\t     * moveTo(580, 300).then(() => console.log('Moved')).catch(err => console.log(err))\n\t     * ```\n\t     */\n\t    moveTo(left, top, positioningOptions) {\n\t        return this.wire\n\t            .sendAction('move-window', {\n\t            left,\n\t            top,\n\t            positioningOptions,\n\t            ...this.identity\n\t        })\n\t            .then(() => undefined);\n\t    }\n\t    /**\n\t     * Resizes the window by a specified amount.\n\t     * @param deltaWidth The change in the width of the window\n\t     * @param deltaHeight The change in the height of the window\n\t     * @param anchor Specifies a corner to remain fixed during the resize.\n\t     * Can take the values: \"top-left\", \"top-right\", \"bottom-left\", or \"bottom-right\".\n\t     * If undefined, the default is \"top-left\"\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWin() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.resizeBy.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     *\n\t     * async function resizeBy(left, top, anchor) {\n\t     *     const win = await createWin();\n\t     *     return await win.resizeBy(left, top, anchor)\n\t     * }\n\t     *\n\t     * resizeBy(580, 300, 'top-right').then(() => console.log('Resized')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    resizeBy(deltaWidth, deltaHeight, anchor, positioningOptions) {\n\t        return this.wire\n\t            .sendAction('resize-window-by', {\n\t            deltaWidth: Math.floor(deltaWidth),\n\t            deltaHeight: Math.floor(deltaHeight),\n\t            anchor,\n\t            positioningOptions,\n\t            ...this.identity\n\t        })\n\t            .then(() => undefined);\n\t    }\n\t    /**\n\t     * Resizes the window to the specified dimensions.\n\t     * @param width The change in the width of the window\n\t     * @param height The change in the height of the window\n\t     * @param anchor Specifies a corner to remain fixed during the resize.\n\t     * Can take the values: \"top-left\", \"top-right\", \"bottom-left\", or \"bottom-right\".\n\t     * If undefined, the default is \"top-left\"\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWin() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.resizeTo.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     *\n\t     * async function resizeTo(left, top, anchor) {\n\t     *     const win = await createWin();\n\t     *     return await win.resizeTo(left, top, anchor);\n\t     * }\n\t     *\n\t     * resizeTo(580, 300, 'top-left').then(() => console.log('Resized')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    resizeTo(width, height, anchor, positioningOptions) {\n\t        return this.wire\n\t            .sendAction('resize-window', {\n\t            width: Math.floor(width),\n\t            height: Math.floor(height),\n\t            anchor,\n\t            positioningOptions,\n\t            ...this.identity\n\t        })\n\t            .then(() => undefined);\n\t    }\n\t    /**\n\t     * Restores the window to its normal state (i.e., unminimized, unmaximized).\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWin() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.restore.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     *\n\t     * async function restore() {\n\t     *     const win = await createWin();\n\t     *     return await win.restore();\n\t     * }\n\t     *\n\t     * restore().then(() => console.log('Restored')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    restore() {\n\t        return this.wire.sendAction('restore-window', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Will bring the window to the front of the entire stack and give it focus.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWin() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.setAsForeground.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     *\n\t     * async function setAsForeground() {\n\t     *     const win = await createWin();\n\t     *     return await win.setAsForeground()\n\t     * }\n\t     *\n\t     * setAsForeground().then(() => console.log('In the foreground')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    setAsForeground() {\n\t        return this.wire.sendAction('set-foreground-window', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Sets the window's size and position.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWin() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.setBounds.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     *\n\t     * async function setBounds(bounds) {\n\t     *     const win = await createWin();\n\t     *     return await win.setBounds(bounds);\n\t     * }\n\t     *\n\t     * setBounds({\n\t     *     height: 100,\n\t     *     width: 200,\n\t     *     top: 400,\n\t     *     left: 400\n\t     * }).then(() => console.log('Bounds set to window')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    setBounds(bounds, positioningOptions) {\n\t        return this.wire\n\t            .sendAction('set-window-bounds', { ...bounds, ...this.identity, positioningOptions })\n\t            .then(() => undefined);\n\t    }\n\t    /**\n\t     * Shows the window if it is hidden.\n\t     * @param force Show will be prevented from showing when force is false and\n\t     *  ‘show-requested’ has been subscribed to for application’s main window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWin() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.show.html',\n\t     *         autoShow: false\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     *\n\t     * async function show() {\n\t     *     const win = await createWin();\n\t     *     return await win.show()\n\t     * }\n\t     *\n\t     * show().then(() => console.log('Showing')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    show(force = false) {\n\t        return this.wire.sendAction('show-window', { force, ...this.identity }).then(() => undefined);\n\t    }\n\t    /**\n\t     * Shows the window if it is hidden at the specified location.\n\t     *\n\t     * @param left The left position of the window in pixels\n\t     * @param top The top position of the window in pixels\n\t     * @param force Show will be prevented from closing when force is false and\n\t     * ‘show-requested’ has been subscribed to for application’s main window\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWin() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.showAt.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     *\n\t     * async function showAt(left, top) {\n\t     *     const win = await createWin();\n\t     *     return await win.showAt(left, top)\n\t     * }\n\t     *\n\t     * showAt(580, 300).then(() => console.log('Showing at')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    showAt(left, top, force = false) {\n\t        return this.wire\n\t            .sendAction('show-at-window', {\n\t            force,\n\t            left: Math.floor(left),\n\t            top: Math.floor(top),\n\t            ...this.identity\n\t        })\n\t            .then(() => undefined);\n\t    }\n\t    /**\n\t     * Shows the Chromium Developer Tools\n\t     *\n\t     * @tutorial Window.showDeveloperTools\n\t     */\n\t    /**\n\t     * Updates the window using the passed options.\n\t     *\n\t     * @remarks Values that are objects are deep-merged, overwriting only the values that are provided.\n\t     * @param options Changes a window's options that were defined upon creation. See tutorial\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function updateOptions() {\n\t     *     const win = await fin.Window.getCurrent();\n\t     *     return win.updateOptions({maxWidth: 100});\n\t     * }\n\t     * updateOptions().then(() => console.log('options is updated')).catch(err => console.error(err));\n\t     * ```\n\t     */\n\t    updateOptions(options) {\n\t        return this.wire.sendAction('update-window-options', { options, ...this.identity }).then(() => undefined);\n\t    }\n\t    /**\n\t     * Provides credentials to authentication requests\n\t     * @param userName userName to provide to the authentication challenge\n\t     * @param password password to provide to the authentication challenge\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.Application.wrap({uuid: 'OpenfinPOC'}).then(app => {\n\t     *     app.on('window-auth-requested', evt => {\n\t     *         let win = fin.Window.wrap({ uuid: evt.uuid, name: evt.name});\n\t     *         win.authenticate('userName', 'P@assw0rd').then(()=> console.log('authenticated')).catch(err => console.log(err));\n\t     *     });\n\t     * });\n\t     * ```\n\t     */\n\t    authenticate(userName, password) {\n\t        return this.wire\n\t            .sendAction('window-authenticate', { userName, password, ...this.identity })\n\t            .then(() => undefined);\n\t    }\n\t    /**\n\t     * Shows a menu on the window.\n\t     *\n\t     * @remarks Returns a promise that resolves when the user has either selected an item or closed the menu. (This may take longer than other apis).\n\t     * Resolves to an object with `{result: 'clicked', data }` where data is the data field on the menu item clicked, or `{result 'closed'}` when the user doesn't select anything.\n\t     * Calling this method will close previously opened menus.\n\t     * @experimental\n\t     * @param options\n\t     * @typeParam Data User-defined shape for data returned upon menu item click.  Should be a\n\t     * [union](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#union-types)\n\t     * of all possible data shapes for the entire menu, and the click handler should process\n\t     * these with a \"reducer\" pattern.\n\t     * @example\n\t     * This could be used to show a drop down menu over views in a platform window:\n\t     * ```js\n\t     * const template = [\n\t     *     {\n\t     *         label: 'Menu Item 1',\n\t     *         data: 'hello from item 1'\n\t     *     },\n\t     *     { type: 'separator' },\n\t     *     {\n\t     *         label: 'Menu Item 2',\n\t     *         type: 'checkbox',\n\t     *         checked: true,\n\t     *         data: 'The user clicked the checkbox'\n\t     *     },\n\t     *     {\n\t     *         label: 'see more',\n\t     *         enabled: false,\n\t     *         submenu: [\n\t     *             { label: 'submenu 1', data: 'hello from submenu' }\n\t     *         ]\n\t     *     }\n\t     * ]\n\t     * fin.me.showPopupMenu({ template }).then(r => {\n\t     *     if (r.result === 'closed') {\n\t     *         console.log('nothing happened');\n\t     *     } else {\n\t     *         console.log(r.data)\n\t     *     }\n\t     * })\n\t     * ```\n\t     *\n\t     * Overriding the built in context menu (note: that this can be done per element or document wide):\n\t     * ```js\n\t     * document.addEventListener('contextmenu', e => {\n\t     *     e.preventDefault();\n\t     *     const template = [\n\t     *         {\n\t     *             label: 'Menu Item 1',\n\t     *             data: 'hello from item 1'\n\t     *         },\n\t     *         { type: 'separator' },\n\t     *         {\n\t     *             label: 'Menu Item 2',\n\t     *             type: 'checkbox',\n\t     *             checked: true,\n\t     *             data: 'The user clicked the checkbox'\n\t     *         },\n\t     *         {\n\t     *             label: 'see more',\n\t     *             enabled: false,\n\t     *             submenu: [\n\t     *                 { label: 'submenu 1', data: 'hello from submenu' }\n\t     *             ]\n\t     *         }\n\t     *     ]\n\t     *     fin.me.showPopupMenu({ template, x: e.x, y: e.y }).then(r => {\n\t     *         if (r.result === 'closed') {\n\t     *             console.log('nothing happened');\n\t     *         } else {\n\t     *             console.log(r.data)\n\t     *         }\n\t     *     })\n\t     * })\n\t     * ```\n\t     */\n\t    async showPopupMenu(options) {\n\t        const { payload } = await this.wire.sendAction('show-popup-menu', { options, ...this.identity });\n\t        return payload.data;\n\t    }\n\t    /**\n\t     * Closes the window's popup menu, if one exists.\n\t     * @experimental\n\t     *\n\t     * @remarks Only one popup menu will ever be showing at a time. Calling `showPopupMenu` will automatically close\n\t     * any existing popup menu.\n\t     *\n\t     *\n\t     * @example\n\t     * This could be used to close a popup menu if the user's mouse leaves an element for example.\n\t     *\n\t     * ```js\n\t     * await fin.me.closePopupMenu();\n\t     * ```\n\t     */\n\t    async closePopupMenu() {\n\t        return this.wire.sendAction('close-popup-menu', { ...this.identity }).then(() => undefined);\n\t    }\n\t    /**\n\t     * Dispatch a result to the caller of `showPopupWindow`.\n\t     *\n\t     * @remarks If this window isn't currently being shown as a popup, this call will silently fail.\n\t     * @param data Serializable data to send to the caller window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * await fin.me.dispatchPopupResult({\n\t     *     foo: 'bar'\n\t     * });\n\t     * ```\n\t     */\n\t    async dispatchPopupResult(data) {\n\t        this.wire.sendAction('window-dispatch-popup-result', this.identity).catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        await this.wire.sendAction('dispatch-popup-result', { data, ...this.identity });\n\t    }\n\t    /**\n\t     * Prints the contents of the window.\n\t     *\n\t     * @param options Configuration for the print task.\n\t     * @remarks When `silent` is set to `true`, the API will pick the system's default printer if deviceName is empty\n\t     * and the default settings for printing.\n\t     *\n\t     * Use the CSS style `page-break-before: always;` to force print to a new page.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * const win = fin.Window.getCurrentSync();\n\t     *\n\t     * win.print({ silent: false, deviceName: 'system-printer-name' }).then(() => {\n\t     *     console.log('print call has been sent to the system');\n\t     * });\n\t     * ```\n\t     *\n\t     * If a window has embedded views, those views will not print by default.  To print a window's contents including embedded views,\n\t     * use the `content` option:\n\t     *\n\t     * ```js\n\t     * const win = fin.Window.getCurrentSync();\n\t     *\n\t     * // Print embedded views\n\t     * win.print({ content: 'views' });\n\t     *\n\t     * // Print screenshot of current window\n\t     * win.print({ content: 'screenshot' })\n\t     * ```\n\t     *\n\t     * When `content` is set to `views`, the embedded views in the platform window will be concatenated and printed as\n\t     * individual pages.  If `includeSelf` is set to `true`, the platform window itself will be printed as the first\n\t     * page - be aware that this page will *not* include the embedded views - it will only include the contents of\n\t     * the platform window itself (e.g. tab stacks), with blank spaces where the view contents would be embedded.\n\t     *\n\t     * Due to a known issue, view contents that are not visible at the time `print` is called will not appear when\n\t     * printing `contents: views`.  This includes views that are obscured behind other active UI elements.\n\t     *\n\t     * To print the views embedded in their page context, set `content` to `screenshot`.\n\t     */\n\t    async print(options = { content: 'self' }) {\n\t        switch (options.content) {\n\t            case undefined:\n\t            case 'self':\n\t                return super.print(options);\n\t            case 'screenshot':\n\t                return this.wire.sendAction('print-screenshot', this.identity).then(() => undefined);\n\t            case 'views':\n\t                return this.wire.sendAction('print-views', { ...this.identity, options }).then(() => undefined);\n\t            default:\n\t                return undefined;\n\t        }\n\t    }\n\t}\n\tInstance$7._Window = _Window;\n\treturn Instance$7;\n}\n\nvar hasRequiredFactory$1;\n\nfunction requireFactory$1 () {\n\tif (hasRequiredFactory$1) return Factory$8;\n\thasRequiredFactory$1 = 1;\n\tObject.defineProperty(Factory$8, \"__esModule\", { value: true });\n\tFactory$8._WindowModule = void 0;\n\tconst base_1 = base;\n\tconst validate_1 = validate;\n\tconst Instance_1 = requireInstance();\n\t/**\n\t * Static namespace for OpenFin API methods that interact with the {@link _Window} class, available under `fin.Window`.\n\t */\n\tclass _WindowModule extends base_1.Base {\n\t    /**\n\t     * Asynchronously returns an API handle for the given Window identity.\n\t     *\n\t     * @remarks Wrapping a Window identity that does not yet exist will *not* throw an error, and instead\n\t     * returns a stub object that cannot yet perform rendering tasks. This can be useful for plumbing eventing\n\t     * for a Window throughout its entire lifecycle.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWin() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.wrap.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     * createWin().then(() => fin.Window.wrap({ uuid: 'app-1', name: 'myApp' }))\n\t     * .then(win => console.log('wrapped window'))\n\t     * .catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    async wrap(identity) {\n\t        this.wire.sendAction('window-wrap').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const errorMsg = (0, validate_1.validateIdentity)(identity);\n\t        if (errorMsg) {\n\t            throw new Error(errorMsg);\n\t        }\n\t        return new Instance_1._Window(this.wire, identity);\n\t    }\n\t    /**\n\t     * Synchronously returns an API handle for the given Window identity.\n\t     *\n\t     * @remarks Wrapping a Window identity that does not yet exist will *not* throw an error, and instead\n\t     * returns a stub object that cannot yet perform rendering tasks. This can be useful for plumbing eventing\n\t     * for a Window throughout its entire lifecycle.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWin() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.wrapSync.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     * await createWin();\n\t     * let win = fin.Window.wrapSync({ uuid: 'app-1', name: 'myApp' });\n\t     * ```\n\t     */\n\t    wrapSync(identity) {\n\t        this.wire.sendAction('window-wrap-sync').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const errorMsg = (0, validate_1.validateIdentity)(identity);\n\t        if (errorMsg) {\n\t            throw new Error(errorMsg);\n\t        }\n\t        return new Instance_1._Window(this.wire, identity);\n\t    }\n\t    /**\n\t     * Creates a new Window.\n\t     * @param options - Window creation options\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWindow() {\n\t     *     const winOption = {\n\t     *         name:'child',\n\t     *         defaultWidth: 300,\n\t     *         defaultHeight: 300,\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.create.html',\n\t     *         frame: true,\n\t     *         autoShow: true\n\t     *     };\n\t     *     return await fin.Window.create(winOption);\n\t     * }\n\t     *\n\t     * createWindow().then(() => console.log('Window is created')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    create(options) {\n\t        this.wire.sendAction('create-window').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const win = new Instance_1._Window(this.wire, { uuid: this.me.uuid, name: options.name });\n\t        return win.createWindow(options);\n\t    }\n\t    /**\n\t     * Asynchronously returns a Window object that represents the current window\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.Window.getCurrent()\n\t     * .then(wnd => console.log('current window'))\n\t     * .catch(err => console.log(err));\n\t     *\n\t     * ```\n\t     */\n\t    getCurrent() {\n\t        this.wire.sendAction('get-current-window').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        if (!this.wire.me.isWindow) {\n\t            throw new Error('You are not in a Window context');\n\t        }\n\t        const { uuid, name } = this.wire.me;\n\t        return this.wrap({ uuid, name });\n\t    }\n\t    /**\n\t     * Synchronously returns a Window object that represents the current window\n\t     *\n\t     * @example\n\t     * ```js\n\t     * const wnd = fin.Window.getCurrentSync();\n\t     * const info = await wnd.getInfo();\n\t     * console.log(info);\n\t     *\n\t     * ```\n\t     */\n\t    getCurrentSync() {\n\t        this.wire.sendAction('get-current-window-sync').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        if (!this.wire.me.isWindow) {\n\t            throw new Error('You are not in a Window context');\n\t        }\n\t        const { uuid, name } = this.wire.me;\n\t        return this.wrapSync({ uuid, name });\n\t    }\n\t}\n\tFactory$8._WindowModule = _WindowModule;\n\treturn Factory$8;\n}\n\nvar hasRequiredWindow;\n\nfunction requireWindow () {\n\tif (hasRequiredWindow) return window$1;\n\thasRequiredWindow = 1;\n\t(function (exports) {\n\t\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t\t    if (k2 === undefined) k2 = k;\n\t\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t\t    }\n\t\t    Object.defineProperty(o, k2, desc);\n\t\t}) : (function(o, m, k, k2) {\n\t\t    if (k2 === undefined) k2 = k;\n\t\t    o[k2] = m[k];\n\t\t}));\n\t\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t\t};\n\t\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t\t/**\n\t\t * Entry points for the OpenFin `Window` API (`fin.Window`).\n\t\t *\n\t\t * * {@link _WindowModule} contains static members of the `Window` API, accessible through `fin.Window`.\n\t\t * * {@link _Window} describes an instance of an OpenFin Window, e.g. as returned by `fin.Window.getCurrent`.\n\t\t *\n\t\t * These are separate code entities, and are documented separately.  In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/32.114.76.10/index.html),\n\t\t * both of these were documented on the same page.\n\t\t *\n\t\t * Underscore prefixing of OpenFin types that alias DOM entities will be fixed in a future version.\n\t\t *\n\t\t * @packageDocumentation\n\t\t */\n\t\t__exportStar(requireFactory$1(), exports);\n\t\t__exportStar(requireInstance(), exports); \n\t} (window$1));\n\treturn window$1;\n}\n\n/**\n * Entry point for the OpenFin `System` API (`fin.System`).\n *\n * * {@link System} contains static members of the `System` API (available under `fin.System`)\n *\n * @packageDocumentation\n */\nObject.defineProperty(system, \"__esModule\", { value: true });\nsystem.System = void 0;\nconst base_1$i = base;\nconst transport_errors_1$1 = transportErrors;\nconst window_1 = requireWindow();\nconst events_1$6 = require$$0;\n/**\n * An object representing the core of OpenFin Runtime. Allows the developer\n * to perform system-level actions, such as accessing logs, viewing processes,\n * clearing the cache and exiting the runtime as well as listen to {@link OpenFin.SystemEvents system events}.\n *\n */\nclass System extends base_1$i.EmitterBase {\n    /**\n     * @internal\n     */\n    constructor(wire) {\n        super(wire, 'system');\n    }\n    sendExternalProcessRequest(action, options) {\n        return new Promise((resolve, reject) => {\n            const exitEventKey = 'external-process-exited';\n            let processUuid;\n            let exitPayload;\n            let externalProcessExitHandler;\n            let ofWindow;\n            if (typeof options.listener === 'function') {\n                externalProcessExitHandler = (payload) => {\n                    const data = payload || {};\n                    exitPayload = {\n                        topic: 'exited',\n                        uuid: data.processUuid || '',\n                        exitCode: data.exitCode || 0\n                    };\n                    if (processUuid === payload.processUuid) {\n                        options.listener(exitPayload);\n                        ofWindow.removeListener(exitEventKey, externalProcessExitHandler);\n                    }\n                };\n                // window constructor expects the name is not undefined\n                if (!this.wire.me.name) {\n                    this.wire.me.name = this.wire.me.uuid;\n                }\n                ofWindow = new window_1._Window(this.wire, this.wire.me);\n                ofWindow.on(exitEventKey, externalProcessExitHandler);\n            }\n            this.wire\n                .sendAction(action, options)\n                .then(({ payload }) => {\n                processUuid = payload.data.uuid;\n                resolve(payload.data);\n                if (exitPayload && processUuid === exitPayload.uuid) {\n                    options.listener(exitPayload);\n                    ofWindow.removeListener(exitEventKey, externalProcessExitHandler);\n                }\n            })\n                .catch((err) => {\n                if (ofWindow) {\n                    ofWindow.removeListener(exitEventKey, externalProcessExitHandler);\n                }\n                reject(err);\n            });\n        });\n    }\n    /**\n     * Returns the version of the runtime. The version contains the major, minor,\n     * build and revision numbers.\n     *\n     * @example\n     * ```js\n     * fin.System.getVersion().then(v => console.log(v)).catch(err => console.log(err));\n     * ```\n     */\n    getVersion() {\n        return this.wire.sendAction('get-version').then(({ payload }) => payload.data);\n    }\n    /**\n     * Clears cached data containing application resource\n     * files (images, HTML, JavaScript files), cookies, and items stored in the\n     * Local Storage.\n     * @param options - See below for details.\n     *\n     * @remarks For more information on the accepted options, see the following pages:\n     * * cache: browsing data cache for html files and images ([caching](https://developer.mozilla.org/en-US/docs/Web/HTTP/Caching))\n     * * cookies: browser [cookies](https://developer.mozilla.org/en-US/docs/Web/HTTP/Cookies)\n     * * localStorage: browser data that can be used across sessions ([local storage](https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage))\n     * * appcache: html5 [application cache](https://developer.mozilla.org/en-US/docs/Web/HTML/Using_the_application_cache)\n     * @example\n     * ```js\n     * const clearCacheOptions = {\n     *     appcache: true,\n     *     cache: true,\n     *     cookies: true,\n     *     localStorage: true\n     * };\n     * fin.System.clearCache(clearCacheOptions).then(() => console.log('Cache cleared')).catch(err => console.log(err));\n     * ```\n     *\n     */\n    clearCache(options) {\n        return this.wire.sendAction('clear-cache', options).then(() => undefined);\n    }\n    /**\n     * Clears all cached data when OpenFin Runtime exits.\n     *\n     * @example\n     * ```js\n     * fin.System.deleteCacheOnExit().then(() => console.log('Deleted Cache')).catch(err => console.log(err));\n     * ```\n     */\n    deleteCacheOnExit() {\n        return this.wire.sendAction('delete-cache-request').then(() => undefined);\n    }\n    /**\n     * Exits the Runtime.\n     *\n     * @example\n     * ```js\n     * fin.System.exit().then(() => console.log('exit')).catch(err => console.log(err));\n     * ```\n     */\n    exit() {\n        return this.wire.sendAction('exit-desktop').then(() => undefined);\n    }\n    /**\n     * Fetches a JSON manifest using the browser process and returns a Javascript object.\n     * @param manifestUrl The URL of the manifest to fetch.\n     *\n     * @example\n     * ```js\n     * const manifest = await fin.System.fetchManifest('https://www.path-to-manifest.com');\n     * console.log(manifest);\n     * ```\n     */\n    async fetchManifest(manifestUrl) {\n        const { payload: { data } } = await this.wire.sendAction('fetch-manifest', { manifestUrl });\n        return data;\n    }\n    /**\n     * Writes any unwritten cookies data to disk.\n     *\n     * @example\n     * ```js\n     * fin.System.flushCookieStore()\n     *     .then(() => console.log('success'))\n     *     .catch(err => console.error(err));\n     * ```\n     */\n    flushCookieStore() {\n        return this.wire.sendAction('flush-cookie-store').then(() => undefined);\n    }\n    /**\n     * Retrieves an array of data (name, ids, bounds) for all application windows.\n     *\n     * @example\n     * ```js\n     * fin.System.getAllWindows().then(wins => console.log(wins)).catch(err => console.log(err));\n     * ```\n     */\n    getAllWindows() {\n        return this.wire.sendAction('get-all-windows').then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves an array of data for all applications.\n     *\n     * @example\n     * ```js\n     * fin.System.getAllApplications().then(apps => console.log(apps)).catch(err => console.log(err));\n     * ```\n     */\n    getAllApplications() {\n        return this.wire.sendAction('get-all-applications').then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves the command line argument string that started OpenFin Runtime.\n     *\n     * @example\n     * ```js\n     * fin.System.getCommandLineArguments().then(args => console.log(args)).catch(err => console.log(err));\n     * ```\n     */\n    getCommandLineArguments() {\n        return this.wire.sendAction('get-command-line-arguments').then(({ payload }) => payload.data);\n    }\n    /**\n     * Get the current state of the crash reporter.\n     *\n     * @example\n     * ```js\n     * fin.System.getCrashReporterState().then(state => console.log(state)).catch(err => console.log(err));\n     * ```\n     */\n    async getCrashReporterState() {\n        const { payload: { data: { diagnosticMode, isRunning } } } = await this.wire.sendAction('get-crash-reporter-state');\n        console.warn('diagnosticMode property is deprecated. It will be removed in a future version');\n        return {\n            // diagnosticMode will be removed in a future version\n            diagnosticMode,\n            diagnosticsMode: diagnosticMode,\n            isRunning\n        };\n    }\n    /**\n     * Start the crash reporter if not already running.\n     * @param options - configure crash reporter\n     *\n     * @remarks You can optionally specify `diagnosticsMode` to have the logs sent to\n     * OpenFin on runtime close. (NOTE: `diagnosticsMode` will turn on verbose logging and disable the sandbox\n     * for newly launched renderer processes. See https://developers.openfin.co/of-docs/docs/debugging#diagnostics-mode for\n     * more details.)\n     *\n     * @example\n     * ```js\n     * fin.System.startCrashReporter({diagnosticsMode: true}).then(reporter => console.log(reporter)).catch(err => console.log(err));\n     * ```\n     */\n    async startCrashReporter(options) {\n        const opts = options;\n        const newOpts = { ...opts, diagnosticMode: opts.diagnosticsMode || opts.diagnosticMode };\n        const { payload: { data: { diagnosticMode, isRunning } } } = await this.wire.sendAction('start-crash-reporter', newOpts);\n        return {\n            // diagnosticMode will be removed in a future version\n            diagnosticMode,\n            diagnosticsMode: diagnosticMode,\n            isRunning\n        };\n    }\n    /**\n     * Returns a hex encoded hash of the machine id and the currently logged in user name.\n     * This is the recommended way to uniquely identify a user / machine combination.\n     *\n     * @remarks For Windows systems this is a sha256 hash of the machine ID set in the registry key:\n     * `HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Cryptography\\MachineGuid` and `USERNAME`.\n     *\n     * For OSX systems, a native-level call is used to get the machine ID.\n     *\n     * @example\n     * ```js\n     * fin.System.getUniqueUserId().then(id => console.log(id)).catch(err => console.log(err));\n     * ```\n     */\n    getUniqueUserId() {\n        return this.wire.sendAction('get-unique-user-id').then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves a frame info object for the uuid and name passed in\n     * @param uuid - The UUID of the target.\n     * @param name - The name of the target.\n     *\n     * @remarks The possible types are 'window', 'iframe', 'external connection' or 'unknown'.\n     * @example\n     * ```js\n     * const entityUuid = 'OpenfinPOC';\n     * const entityName = '40c74b5d-ed98-40f7-853f-e3d3c2699175';\n     * fin.System.getEntityInfo(entityUuid, entityName).then(info => console.log(info)).catch(err => console.log(err));\n     *\n     * // example info shape\n     * {\n     *     \"uuid\": \"OpenfinPOC\",\n     *     \"name\": \"40c74b5d-ed98-40f7-853f-e3d3c2699175\",\n     *     \"parent\": {\n     *         \"uuid\": \"OpenfinPOC\",\n     *         \"name\": \"OpenfinPOC\"\n     *     },\n     *     \"entityType\": \"iframe\"\n     * }\n     * ```\n     */\n    getEntityInfo(uuid, name) {\n        return this.wire.sendAction('get-entity-info', { uuid, name }).then(({ payload }) => payload.data);\n    }\n    /**\n     * Gets the value of a given environment variable on the computer on which the runtime is installed\n     *\n     * @example\n     * ```js\n     * fin.System.getEnvironmentVariable('HOME').then(env => console.log(env)).catch(err => console.log(err));\n     * ```\n     */\n    getEnvironmentVariable(envName) {\n        return this.wire\n            .sendAction('get-environment-variable', {\n            environmentVariables: envName\n        })\n            .then(({ payload }) => payload.data);\n    }\n    /**\n     * Get currently focused Window.\n     * If a View currently has focus, returns the identity of View's parent Window.\n     * Use {@link Window._Window#getFocusedContent Window.getFocusedContent} to directly access currently focused Window or View.\n     *\n     * @example\n     * ```js\n     * fin.System.getFocusedWindow().then(winInfo => console.log(winInfo)).catch(err => console.log(err));\n     * ```\n     */\n    getFocusedWindow() {\n        return this.wire.sendAction('get-focused-window').then(({ payload }) => payload.data);\n    }\n    /**\n     * Get currently focused content. Returns identity of entity with `entityType`.\n     *\n     * @example\n     * ```js\n     * fin.System.getFocusedContent().then(contentIdentity => console.log(contentIdentity)).catch(err => console.log(err));\n     * ```\n     */\n    getFocusedContent() {\n        return this.wire.sendAction('get-focused-content').then(({ payload }) => payload.data);\n    }\n    /**\n     * Returns information about the given app's certification status\n     *\n     * @example\n     * ```js\n     * const manifestUrl = \"http://localhost:1234/app.json\"\n     * try {\n     *     const certificationInfo = await fin.System.isAppCertified(manifestUrl);\n     * } catch(err) {\n     *     console.error(err)\n     * }\n     * ```\n     */\n    async isAppCertified(manifestUrl) {\n        const { payload: { data: { certifiedInfo } } } = await this.wire.sendAction('is-app-certified', { manifestUrl });\n        return certifiedInfo;\n    }\n    /**\n     * Returns an array of all the installed runtime versions in an object.\n     *\n     * @example\n     * ```js\n     * fin.System.getInstalledRuntimes().then(runtimes => console.log(runtimes)).catch(err => console.log(err));\n     * ```\n     */\n    // incompatible with standalone node process.\n    getInstalledRuntimes() {\n        return this.wire.sendAction('get-installed-runtimes').then(({ payload }) => payload.data.runtimes);\n    }\n    // incompatible with standalone node process.\n    async getInstalledApps() {\n        const { payload: { data: { installedApps } } } = await this.wire.sendAction('get-installed-apps');\n        return installedApps;\n    }\n    /**\n     * Retrieves the contents of the log with the specified filename.\n     * @param options A object that id defined by the GetLogRequestType interface\n     *\n     * @example\n     * ```js\n     * async function getLog() {\n     *     const logs = await fin.System.getLogList();\n     *     return await fin.System.getLog(logs[0]);\n     * }\n     *\n     * getLog().then(log => console.log(log)).catch(err => console.log(err));\n     * ```\n     */\n    getLog(options) {\n        return this.wire.sendAction('view-log', options).then(({ payload }) => payload.data);\n    }\n    /**\n     * Returns a unique identifier (UUID) provided by the machine.\n     *\n     * @example\n     * ```js\n     * fin.System.getMachineId().then(id => console.log(id)).catch(err => console.log(err));\n     * ```\n     */\n    getMachineId() {\n        return this.wire.sendAction('get-machine-id').then(({ payload }) => payload.data);\n    }\n    /**\n     * Returns the minimum (inclusive) logging level that is currently being written to the log.\n     *\n     * @example\n     * ```js\n     * fin.System.getMinLogLevel().then(level => console.log(level)).catch(err => console.log(err));\n     * ```\n     */\n    getMinLogLevel() {\n        return this.wire.sendAction('get-min-log-level').then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves an array containing information for each log file.\n     *\n     * @example\n     * ```js\n     * fin.System.getLogList().then(logList => console.log(logList)).catch(err => console.log(err));\n     * ```\n     */\n    getLogList() {\n        return this.wire.sendAction('list-logs').then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves an object that contains data about the monitor setup of the\n     * computer that the runtime is running on.\n     *\n     * @example\n     * ```js\n     * fin.System.getMonitorInfo().then(monitorInfo => console.log(monitorInfo)).catch(err => console.log(err));\n     * ```\n     */\n    getMonitorInfo() {\n        return this.wire.sendAction('get-monitor-info').then(({ payload }) => payload.data);\n    }\n    /**\n     * Returns the mouse in virtual screen coordinates (left, top).\n     *\n     * @example\n     * ```js\n     * fin.System.getMousePosition().then(mousePosition => console.log(mousePosition)).catch(err => console.log(err));\n     * ```\n     */\n    getMousePosition() {\n        return this.wire.sendAction('get-mouse-position').then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves an array of all of the runtime processes that are currently\n     * running. Each element in the array is an object containing the uuid\n     * and the name of the application to which the process belongs.\n     * @deprecated Please use our new set of process APIs:\n     * {@link Window._Window#getProcessInfo Window.getProcessInfo}\n     * {@link View.View#getProcessInfo View.getProcessInfo}\n     * {@link Application.Application#getProcessInfo Application.getProcessInfo}\n     * {@link System#getAllProcessInfo System.getAllProcessInfo}\n     *\n     * @example\n     * ```js\n     * fin.System.getProcessList().then(ProcessList => console.log(ProcessList)).catch(err => console.log(err));\n     * ```\n     */\n    getProcessList() {\n        // eslint-disable-next-line no-console\n        console.warn('System.getProcessList has been deprecated. Please consider using our new process APIs: Window.getProcessInfo, View.getProcessInfo, Application.getProcessInfo, System.getAllProcessInfo');\n        return this.wire.sendAction('process-snapshot').then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves all process information.\n     *\n     * @remarks This includes the browser process and every process associated to all entities (windows and views).\n     *\n     * @example\n     * ```js\n     * const allProcessInfo = await fin.System.getAllProcessInfo();\n     * ```\n     * @experimental\n     */\n    async getAllProcessInfo() {\n        const { payload: { data } } = await this.wire.sendAction('get-all-process-info', this.identity);\n        return data;\n    }\n    /**\n     * Retrieves the Proxy settings.\n     *\n     * @example\n     * ```js\n     * fin.System.getProxySettings().then(ProxySetting => console.log(ProxySetting)).catch(err => console.log(err));\n     *\n     * //This response has the following shape:\n     * {\n     *     config: {\n     *         proxyAddress: \"proxyAddress\", //the configured Proxy Address\n     *         proxyPort: 0, //the configured Proxy port\n     *         type: \"system\" //Proxy Type\n     *     },\n     *     system: {\n     *         autoConfigUrl: \"\",\n     *         bypass: \"\",\n     *         enabled: false,\n     *         proxy: \"\"\n     *     }\n     * }\n     * ```\n     */\n    getProxySettings() {\n        return this.wire.sendAction('get-proxy-settings').then(({ payload }) => payload.data);\n    }\n    /**\n     * Returns information about the running Runtime in an object.\n     *\n     * @example\n     * ```js\n     * fin.System.getRuntimeInfo().then(RuntimeInfo => console.log(RuntimeInfo)).catch(err => console.log(err));\n     * ```\n     */\n    getRuntimeInfo() {\n        return this.wire.sendAction('get-runtime-info').then(({ payload }) => payload.data);\n    }\n    /**\n     * Returns information about the running RVM in an object.\n     *\n     * @example\n     * ```js\n     * fin.System.getRvmInfo().then(RvmInfo => console.log(RvmInfo)).catch(err => console.log(err));\n     * ```\n     */\n    // incompatible with standalone node process.\n    getRvmInfo() {\n        return this.wire.sendAction('get-rvm-info').then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves general system information. If you need more detailed information about the\n     * OS and the currently logged in user, use `fin.System.getOSInfo()` instead.\n     *\n     * @example\n     * ```js\n     * fin.System.getHostSpecs().then(specs => console.log(specs)).catch(err => console.log(err));\n     * ```\n     */\n    getHostSpecs() {\n        return this.wire.sendAction('get-host-specs').then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves information about the OS and the currently logged in user.\n     *\n     * @example\n     * ```js\n     * fin.System.getOSInfo().then(specs => console.log(specs)).catch(err => console.log(err));\n     * ```\n     */\n    getOSInfo() {\n        return this.wire.sendAction('get-os-info').then(({ payload }) => payload.data);\n    }\n    /**\n     * Runs an executable or batch file. A path to the file must be included in options.\n     * <br> A uuid may be optionally provided. If not provided, OpenFin will create a uuid for the new process.\n     * <br> Note: This method is restricted by default and must be enabled via\n     * <a href=\"https://developers.openfin.co/docs/api-security\">API security settings</a>. Also, this api has an enhanced permission set to make it less dangerous. So application owners can only allow to launch the assets owned by the application, the enabled downloaded files or the restricted executables.\n     * @param options A object that is defined in the ExternalProcessRequestType interface\n     *\n     * @remarks If an unused UUID is provided in options, it will be used. If no UUID is provided, OpenFin will assign one.\n     * This api has an enhanced permission set to make it less dangerous. So application owners can only allow to launch the\n     * assets owned by the application, the enabled downloaded files or the restricted executables.\n     *\n     * **Note:** Since _appAssets_ relies on the RVM, which is missing on MAC_OS, 'alias' is not available. Instead provide\n     * the full path e.g. _/Applications/Calculator.app/Contents/MacOS/Calculator_.\n     *\n     * @example\n     * Basic Example:\n     * ```js\n     * fin.System.launchExternalProcess({\n     *     path: 'notepad',\n     *     arguments: '',\n     *     listener: function (result) {\n     *         console.log('the exit code', result.exitCode);\n     *     }\n     * }).then(processIdentity => {\n     *     console.log(processIdentity);\n     * }).catch(error => {\n     *     console.log(error);\n     * });\n     * ```\n     *\n     * Promise resolution:\n     *\n     * ```js\n     * //This response has the following shape:\n     * {\n     *     uuid: \"FB3E6E36-0976-4C2B-9A09-FB2E54D2F1BB\" // The mapped UUID which identifies the launched process\n     * }\n     * ```\n     *\n     * Listener callback:\n     * ```js\n     * //This response has the following shape:\n     * {\n     *     topic: \"exited\", // Or \"released\" on a call to releaseExternalProcess\n     *     uuid: \"FB3E6E36-0976-4C2B-9A09-FB2E54D2F1BB\", // The mapped UUID which identifies the launched process\n     *     exitCode: 0 // Process exit code\n     * }\n     * ```\n     *\n     * By specifying a lifetime, an external process can live as long the window/application that launched it or\n     * persist after the application exits. The default value is null, which is equivalent to 'persist', meaning\n     * the process lives on after the application exits:\n     *\n     * ```js\n     * fin.System.launchExternalProcess({\n     *     path: 'notepad',\n     *     arguments: '',\n     *     listener: (result) => {\n     *         console.log('the exit code', result.exitCode);\n     *     },\n     *     lifetime: 'window'\n     * }).then(processIdentity => {\n     *     console.log(processIdentity);\n     * }).catch(error => {\n     *     console.log(error);\n     * });\n     * ```\n     *\n     * Note: A process that exits when the window/application exits cannot be released via fin.desktop.System.releaseExternalProcess.\n     *\n     * By specifying a cwd, it will set current working directory when launching an external process:\n     *\n     * ```js\n     * fin.System.launchExternalProcess({\n     *     path: 'cmd.exe',\n     *     cwd: 'c:\\\\temp',\n     *     arguments: '',\n     *     listener: (result) => {\n     *         console.log('the exit code', result.exitCode);\n     *     }\n     * }).then(processIdentity => {\n     *     console.log(processIdentity);\n     * }).catch(error => {\n     *     console.log(error);\n     * });\n     * ```\n     *\n     * Example using an alias from app.json appAssets property:\n     *\n     * ```json\n     * \"appAssets\": [\n     *     {\n     *         \"src\": \"exe.zip\",\n     *         \"alias\": \"myApp\",\n     *         \"version\": \"4.12.8\",\n     *         \"target\": \"myApp.exe\",\n     *         \"args\": \"a b c d\"\n     *     },\n     * ]\n     * ```\n     *\n     * ```js\n     * //  When called, if no arguments are passed then the arguments (if any)\n     * //  are taken from the 'app.json' file, from the  'args' parameter\n     * //  of the 'appAssets' Object with the relevant 'alias'.\n     * fin.System.launchExternalProcess({\n     *     //Additionally note that the executable found in the zip file specified in appAssets\n     *     //will default to the one mentioned by appAssets.target\n     *     //If the the path below refers to a specific path it will override this default\n     *     alias: 'myApp',\n     *     listener: (result) => {\n     *         console.log('the exit code', result.exitCode);\n     *     }\n     * }).then(processIdentity => {\n     *     console.log(processIdentity);\n     * }).catch(error => {\n     *     console.log(error);\n     * });\n     * ```\n     *\n     * Example using an alias but overriding the arguments:\n     *\n     * ```json\n     * \"appAssets\": [\n     *     {\n     *         \"src\": \"exe.zip\",\n     *         \"alias\": \"myApp\",\n     *         \"version\": \"4.12.8\",\n     *         \"target\": \"myApp.exe\",\n     *         \"args\": \"a b c d\"\n     *     },\n     * ]\n     * ```\n     *\n     * ```js\n     * //  If 'arguments' is passed as a parameter it takes precedence\n     * //  over any 'args' set in the 'app.json'.\n     * fin.System.launchExternalProcess({\n     *     alias: 'myApp',\n     *     arguments: 'e f g',\n     *     listener: (result) => {\n     *         console.log('the exit code', result.exitCode);\n     *     }\n     * }).then(processIdentity => {\n     *     console.log(processIdentity);\n     * }).catch(error => {\n     *     console.log(error);\n     * });\n     * ```\n     *\n     * It is now possible to optionally perform any combination of the following certificate checks\n     * against an absolute target via `fin.desktop.System.launchExternalProcess()`:\n     *\n     * ```js\n     * \"certificate\": {\n     *     \"serial\": \"3c a5 ...\",                        // A hex string with or without spaces\n     *     \"subject\": \"O=OpenFin INC., L=New York, ...\", // An internally tokenized and comma delimited string allowing partial or full checks of the subject fields\n     *     \"publickey\": \"3c a5 ...\",                     // A hex string with or without spaces\n     *     \"thumbprint\": \"3c a5 ...\",                    // A hex string with or without spaces\n     *     \"trusted\": true                               // A boolean indicating that the certificate is trusted and not revoked\n     * }\n     * ```\n     *\n     * Providing this information as part of the default configurations for assets in an application's manifest\n     * will be added in a future RVM update:\n     *\n     * ```js\n     * fin.System.launchExternalProcess({\n     *     path: 'C:\\\\Users\\\\ExampleUser\\\\AppData\\\\Local\\\\OpenFin\\\\OpenFinRVM.exe',\n     *     arguments: '--version',\n     *     certificate: {\n     *         trusted: true,\n     *         subject: 'O=OpenFin INC., L=New York, S=NY, C=US',\n     *         thumbprint: '‎3c a5 28 19 83 05 fe 69 88 e6 8f 4b 3a af c5 c5 1b 07 80 5b'\n     *     },\n     *     listener: (result) => {\n     *         console.log('the exit code', result.exitCode);\n     *     }\n     * }).then(processIdentity => {\n     *     console.log(processIdentity);\n     * }).catch(error => {\n     *     console.log(error);\n     * });\n     * ```\n     *\n     * It is possible to launch files that have been downloaded by the user by listening to the window\n     * `file-download-completed` event and using the `fileUuid` provided by the event:\n     *\n     * ```js\n     * const win = fin.Window.getCurrentSync();\n     * win.addListener('file-download-completed', (evt) => {\n     *     if (evt.state === 'completed') {\n     *         fin.System.launchExternalProcess({\n     *             fileUuid: evt.fileUuid,\n     *             arguments: '',\n     *             listener: (result) => {\n     *                 console.log('the exit code', result.exitCode);\n     *             }\n     *         }).then(processIdentity => {\n     *             console.log(processIdentity);\n     *         }).catch(error => {\n     *             console.log(error);\n     *         });\n     *     }\n     * });\n     * ```\n     *\n     * Launching assets specified in the app manifest:\n     *\n     * Sample appAssets section in app.json\n     * ```js\n     *     \"appAssets\": [\n     *         {\n     *             \"src\": \"http://filesamples.com/exe.zip\",\n     *             \"alias\": \"myApp\",\n     *             \"version\": \"4.12.8\",\n     *             \"target\": \"myApp.exe\",\n     *             \"args\": \"a b c d\"\n     *         },\n     *         {\n     *             \"src\": \"http://examples.com/exe.zip\",\n     *             \"alias\": \"myApp2\",\n     *             \"version\": \"5.12.8\",\n     *             \"target\": \"myApp2.exe\",\n     *             \"args\": \"a b c\"\n     *         }\n     *     ]\n     * ```\n     *\n     * This permission allows for launching of all assets specified in the above appAssets section. (\"myApp\" and \"myApp2\"):\n     *\n     * ```js\n     *     \"permissions\": {\n     *        \"System\": {\n     *            \"launchExternalProcess\": {\n     *                 \"enabled\": true,\n     *                 \"assets\": {\n     *                     \"enabled\": true\n     *                 }\n     *             }\n     *        }\n     *     }\n     * ```\n     *\n     * This permission allows for launching of _only_ the \"myApp\" asset in the above appAssets section, as defined in `srcRules`:\n     * ```js\n     *     \"permissions\": {\n     *        \"System\": {\n     *            \"launchExternalProcess\": {\n     *                 \"enabled\": true,\n     *                 \"assets\": {\n     *                     \"enabled\": true\n     *                     \"srcRules\": [\n     *                         {\n     *                             \"match\": [\n     *                                 \"*://filesamples.com/*\"\n     *                             ],\n     *                             \"behavior\": \"allow\"\n     *                         },\n     *                         {\n     *                             \"match\": [\n     *                                 \"<all_urls>\"\n     *                             ],\n     *                             \"behavior\": \"block\"\n     *                         }\n     *                     ]\n     *                 }\n     *             }\n     *        }\n     *     }\n     * ```\n     *\n     * Launching downloaded files:\n     * ```js\n     *     \"permissions\": {\n     *        \"System\": {\n     *            \"launchExternalProcess\": {\n     *                 \"enabled\": true,\n     *                 \"downloads\": {\n     *                     \"enabled\": true\n     *                 }\n     *             }\n     *        }\n     *     }\n     * ```\n     *\n     * This permission allows to launch all the executables:\n     * ```js\n     *     \"permissions\": {\n     *        \"System\": {\n     *            \"launchExternalProcess\": {\n     *                 \"enabled\": true,\n     *                 \"executables\": {\n     *                     \"enabled\": true\n     *                 }\n     *             }\n     *        }\n     *     }\n     * ```\n     *\n     *\n     * This permission only allows launching of executables whose file paths match the corresponding `pathRules`:\n     * ```js\n     *     \"permissions\": {\n     *        \"System\": {\n     *            \"launchExternalProcess\": {\n     *                 \"enabled\": true,\n     *                 \"executables\": {\n     *                     \"enabled\": true\n     *                     \"pathRules\": [\n     *                         {\n     *                             \"match\": [\n     *                                 \"/Windows/System32/*.exe\"\n     *                             ],\n     *                             \"behavior\": \"allow\"\n     *                         },\n     *                         {\n     *                             \"match\": [\n     *                                 \"*.exe\"\n     *                             ],\n     *                             \"behavior\": \"block\"\n     *                         }\n     *                     ]\n     *                 }\n     *             }\n     *        }\n     *     }\n     * ```\n     */\n    launchExternalProcess(options) {\n        return this.sendExternalProcessRequest('launch-external-process', options);\n    }\n    /**\n     * Monitors a running process. A pid for the process must be included in options.\n     * <br> A uuid may be optionally provided. If not provided, OpenFin will create a uuid for the new process.\n     *\n     * @remarks If an unused uuid is provided in options, it will be used. If no uuid is provided, OpefinFin will assign a uuid.\n     * @example\n     * ```js\n     * fin.System.monitorExternalProcess({\n     *     pid: 10208,\n     *     uuid: 'my-external-process', // optional\n     *     listener: function (result) {\n     *         console.log('the exit code', result.exitCode);\n     *     }\n     * }).then(processIdentity => console.log(processIdentity)).catch(err => console.log(err));\n     * ```\n     */\n    monitorExternalProcess(options) {\n        return this.sendExternalProcessRequest('monitor-external-process', options);\n    }\n    /**\n     * Writes the passed message into both the log file and the console.\n     * @param level The log level for the entry. Can be either \"info\", \"warning\" or \"error\"\n     * @param message The log message text\n     *\n     * @example\n     * ```js\n     * fin.System.log(\"info\", \"An example log message\").then(() => console.log('Log info message')).catch(err => console.log(err));\n     * ```\n     */\n    log(level, message) {\n        return this.wire.sendAction('write-to-log', { level, message }).then(() => undefined);\n    }\n    /**\n     * Opens the passed URL in the default web browser.\n     *\n     * @remarks It only supports http(s) and fin(s) protocols by default.\n     * In order to use other custom protocols, they have to be enabled via\n     * [API security settings](https://developers.openfin.co/docs/api-security).\n     * File protocol and file path are not supported.\n     * @param url The URL to open\n     *\n     * @example\n     * ```js\n     * fin.System.openUrlWithBrowser('https://cdn.openfin.co/docs/javascript/stable/tutorial-System.openUrlWithBrowser.html')\n     * .then(() => console.log('Opened URL'))\n     * .catch(err => console.log(err));\n     * ```\n     *\n     * Example of permission definition to enable non-default protocols:\n     *\n     * Note: permission definition should be specified in an app manifest file if there is no DOS settings.\n     * Otherwise it has to be specified in both DOS and app manifest files.\n     *\n     * ```js\n     *     \"permissions\": {\n     *        \"System\": {\n     *            \"openUrlWithBrowser\": {\n     *                 \"enabled\": true,\n     *                 \"protocols\": [ \"msteams\", \"slack\"]\n     *             }\n     *        }\n     *     }\n     * ```\n     */\n    openUrlWithBrowser(url) {\n        return this.wire.sendAction('open-url-with-browser', { url }).then(() => undefined);\n    }\n    /**\n     * Creates a new registry entry under the HKCU root Windows registry key if the given custom protocol name doesn't exist or\n     * overwrites the existing registry entry if the given custom protocol name already exists.\n     *\n     * Note: This method is restricted by default and must be enabled via\n     * {@link https://developers.openfin.co/docs/api-security API security settings}. It requires RVM 12 or higher version.\n     *\n     *\n     * @remarks These protocols are reserved and cannot be registered:\n     * - fin\n     * - fins\n     * - openfin\n     * - URI Schemes registered with {@link https://en.wikipedia.org/wiki/List_of_URI_schemes#Official_IANA-registered_schemes IANA}\n     *\n     * @throws if a given custom protocol failed to be registered.\n     * @throws if a manifest URL contains the '%1' string.\n     * @throws if a manifest URL contains a query string parameter which name equals to the Protocol Launch Request Parameter Name.\n     * @throws if the full length of the command string that is to be written to the registry exceeds 2048 bytes.\n     *\n     * @example\n     * ```js\n     * fin.System.registerCustomProtocol({protocolName:'protocol1'}).then(console.log).catch(console.error);\n     * ```\n     */\n    async registerCustomProtocol(options) {\n        if (typeof options !== 'object') {\n            throw new Error('Must provide an object with a `protocolName` property having a string value.');\n        }\n        await this.wire.sendAction('register-custom-protocol', options);\n    }\n    /**\n     * Removes the registry entry for a given custom protocol.\n     *\n     * Note: This method is restricted by default and must be enabled via\n     * {@link https://developers.openfin.co/docs/api-security API security settings}. It requires RVM 12 or higher version.\n     *\n     *\n     * @remarks These protocols are reserved and cannot be unregistered:\n     * - fin\n     * - fins\n     * - openfin\n     * - URI Schemes registered with {@link https://en.wikipedia.org/wiki/List_of_URI_schemes#Official_IANA-registered_schemes IANA}\n     *\n     * @throws if a protocol entry failed to be removed in registry.\n     *\n     * @example\n     * ```js\n     * await fin.System.unregisterCustomProtocol('protocol1');\n     * ```\n     */\n    async unregisterCustomProtocol(protocolName) {\n        await this.wire.sendAction('unregister-custom-protocol', { protocolName });\n    }\n    /**\n     * Retrieves the registration state for a given custom protocol.\n     *\n     * Note: This method is restricted by default and must be enabled via\n     * {@link https://developers.openfin.co/docs/api-security API security settings}. It requires RVM 12 or higher version.\n     *\n     * @remarks These protocols are reserved and cannot get states for them:\n     * - fin\n     * - fins\n     * - openfin\n     * - URI Schemes registered with {@link https://en.wikipedia.org/wiki/List_of_URI_schemes#Official_IANA-registered_schemes IANA}\n     *\n     *\n     * @example\n     * ```js\n     * const protocolState = await fin.System.getCustomProtocolState('protocol1');\n     */\n    async getCustomProtocolState(protocolName) {\n        return this.wire.sendAction('get-custom-protocol-state', { protocolName }).then(({ payload }) => payload.data);\n    }\n    /**\n     * Removes the process entry for the passed UUID obtained from a prior call\n     * of fin.System.launchExternalProcess().\n     * @param uuid The UUID for a process obtained from a prior call to fin.desktop.System.launchExternalProcess()\n     *\n     * @example\n     * ```js\n     * fin.System.launchExternalProcess({\n     *     path: \"notepad\",\n     *     listener: function (result) {\n     *         console.log(\"The exit code\", result.exitCode);\n     *     }\n     * })\n     * .then(identity => fin.System.releaseExternalProcess(identity.uuid))\n     * .then(() => console.log('Process has been unmapped!'))\n     * .catch(err => console.log(err));\n     * ```\n     */\n    releaseExternalProcess(uuid) {\n        return this.wire.sendAction('release-external-process', { uuid }).then(() => undefined);\n    }\n    /**\n     * Shows the Chromium Developer Tools for the specified window\n     * @param identity This is a object that is defined by the Identity interface\n     *\n     * @tutorial System.showDeveloperTools\n     */\n    showDeveloperTools(identity) {\n        return this.wire.sendAction('show-developer-tools', identity).then(() => undefined);\n    }\n    /**\n     * Attempt to close an external process. The process will be terminated if it\n     * has not closed after the elapsed timeout in milliseconds.\n     *\n     * Note: This method is restricted by default and must be enabled via\n     * <a href=\"https://developers.openfin.co/docs/api-security\">API security settings</a>.\n     * @param options A object defined in the TerminateExternalRequestType interface\n     *\n     * @example\n     * ```js\n     * fin.System.launchExternalProcess({\n     *     path: \"notepad\",\n     *     listener: function (result) {\n     *         console.log(\"The exit code\", result.exitCode);\n     *     }\n     * })\n     * .then(identity => fin.System.terminateExternalProcess({uuid: identity.uuid, timeout:2000, killTree: false}))\n     * .then(() => console.log('Terminate the process'))\n     * .catch(err => console.log(err));\n     * ```\n     */\n    terminateExternalProcess(options) {\n        return this.wire.sendAction('terminate-external-process', options).then(() => undefined);\n    }\n    /**\n     * Update the OpenFin Runtime Proxy settings.\n     * @param options A config object defined in the ProxyConfig interface\n     *\n     * @example\n     * ```js\n     * fin.System.updateProxySettings({proxyAddress:'127.0.0.1', proxyPort:8080, type:'http'})\n     * .then(() => console.log('Update proxy successfully'))\n     * .catch(err => console.error(err));\n     * ```\n     */\n    updateProxySettings(options) {\n        return this.wire.sendAction('update-proxy', options).then(() => undefined);\n    }\n    /**\n     * Downloads the given application asset.\n     *\n     * Note: This method is restricted by default and must be enabled via\n     * <a href=\"https://developers.openfin.co/docs/api-security\">API security settings</a>.\n     * @param appAsset App asset object\n     *\n     * @example\n     * ```js\n     * async function downloadAsset() {\n     *     const appAsset = {\n     *         src: `${ location.origin }/assets.zip`,\n     *         alias: 'dirApp',\n     *         version: '1.23.24',\n     *         target: 'assets/run.bat'\n     *     };\n     *\n     *     return fin.System.downloadAsset(appAsset, (progress => {\n     *     //Print progress as we download the asset.\n     *         const downloadedPercent = Math.floor((progress.downloadedBytes / progress.totalBytes) * 100);\n     *         console.log(`Downloaded ${downloadedPercent}%`);\n     *     }));\n     * }\n     *\n     * downloadAsset()\n     * .then(() => console.log('Success'))\n     * .catch(err => console.error(err));\n     *\n     * ```\n     */\n    // incompatible with standalone node process.\n    async downloadAsset(appAsset, progressListener) {\n        // eslint-disable-next-line @typescript-eslint/explicit-function-return-type, @typescript-eslint/no-empty-function\n        const noop = () => { };\n        let resolve = noop;\n        let reject = noop;\n        const downloadCompletePromise = new Promise((y, n) => {\n            resolve = y;\n            reject = n;\n        });\n        // node.js environment not supported\n        if (this.wire.environment.type !== 'openfin') {\n            throw new transport_errors_1$1.NotSupportedError('downloadAsset only supported in an OpenFin Render process');\n        }\n        const callSite = transport_errors_1$1.RuntimeError.getCallSite();\n        const downloadId = this.wire.environment.getNextMessageId().toString();\n        const dlProgressKey = `asset-download-progress-${downloadId}`;\n        const dlErrorKey = `asset-download-error-${downloadId}`;\n        const dlCompleteKey = `asset-download-complete-${downloadId}`;\n        const dlProgress = (progress) => {\n            const p = {\n                downloadedBytes: progress.downloadedBytes,\n                totalBytes: progress.totalBytes\n            };\n            progressListener(p);\n        };\n        const cleanListeners = () => {\n            // TODO: fix internal types\n            // @ts-expect-error\n            this.removeListener(dlProgressKey, dlProgress);\n        };\n        const dlError = (payload) => {\n            cleanListeners();\n            const { reason, err: error } = payload;\n            reject(new transport_errors_1$1.RuntimeError({ reason, error }, callSite));\n        };\n        const dlComplete = () => {\n            cleanListeners();\n            resolve();\n        };\n        await Promise.all([\n            // TODO: fix internal types\n            // @ts-expect-error\n            this.on(dlProgressKey, dlProgress),\n            // TODO: fix internal types\n            // @ts-expect-error\n            this.once(dlErrorKey, dlError),\n            // TODO: fix internal types\n            // @ts-expect-error\n            this.once(dlCompleteKey, dlComplete)\n        ]);\n        const downloadOptions = Object.assign(appAsset, { downloadId });\n        await this.wire.sendAction('download-asset', downloadOptions).catch((err) => {\n            cleanListeners();\n            throw err;\n        });\n        return downloadCompletePromise;\n    }\n    /**\n     * Downloads a version of the runtime.\n     * @param options - Download options.\n     * @param progressListener - called as the runtime is downloaded with progress information.\n     *\n     * @remarks Only supported in an OpenFin Render process.\n     *\n     * @example\n     * ```js\n     * var downloadOptions = {\n     *     //Specific version number required, if given a release channel the call will produce an error.\n     *     version: '9.61.30.1'\n     * };\n     *\n     * function onProgress(progress) {\n     *     console.log(`${Math.floor((progress.downloadedBytes / progress.totalBytes) * 100)}%`);\n     * }\n     *\n     * fin.System.downloadRuntime(downloadOptions, onProgress).then(() => {\n     *     console.log('Download complete');\n     * }).catch(err =>    {\n     *     console.log(`Download Failed, we could retry: ${err.message}`);\n     *     console.log(err);\n     * });\n     * ```\n     */\n    downloadRuntime(options, progressListener) {\n        const callsites = transport_errors_1$1.RuntimeError.getCallSite();\n        return new Promise((resolve, reject) => {\n            // node.js environment not supported\n            if (this.wire.environment.type !== 'openfin') {\n                reject(new transport_errors_1$1.NotSupportedError('downloadRuntime only supported in an OpenFin Render process'));\n                return;\n            }\n            const downloadId = this.wire.environment.getNextMessageId().toString();\n            const dlProgressKey = `runtime-download-progress-${downloadId}`;\n            const dlErrorKey = `runtime-download-error-${downloadId}`;\n            const dlCompleteKey = `runtime-download-complete-${downloadId}`;\n            const dlProgress = (progress) => {\n                const p = {\n                    downloadedBytes: progress.downloadedBytes,\n                    totalBytes: progress.totalBytes\n                };\n                progressListener(p);\n            };\n            const cleanListeners = () => {\n                // TODO: fix internal types\n                // @ts-expect-error\n                this.removeListener(dlProgressKey, dlProgress);\n            };\n            const dlError = (payload) => {\n                cleanListeners();\n                const { reason, err: error } = payload;\n                reject(new transport_errors_1$1.RuntimeError({ reason, error }, callsites));\n            };\n            const dlComplete = () => {\n                cleanListeners();\n                resolve();\n            };\n            // TODO: fix internal types\n            // @ts-expect-error\n            this.on(dlProgressKey, dlProgress);\n            // TODO: fix internal types\n            // @ts-expect-error\n            this.once(dlErrorKey, dlError);\n            // TODO: fix internal types\n            // @ts-expect-error\n            this.once(dlCompleteKey, dlComplete);\n            const downloadOptions = Object.assign(options, { downloadId });\n            this.wire.sendAction('download-runtime', downloadOptions).catch((err) => {\n                cleanListeners();\n                reject(err);\n            });\n        });\n    }\n    /**\n     * Download preload scripts from given URLs\n     * @param scripts - URLs of preload scripts.\n     *\n     * @example\n     * ```js\n     * const scripts = [\n     *     { url: 'http://.../preload.js' },\n     *     { url: 'http://.../preload2.js' }\n     * ];\n     *\n     * fin.System.downloadPreloadScripts(scripts).then(results => {\n     *     results.forEach(({url, success, error}) => {\n     *         console.log(`URL: ${url}`);\n     *         console.log(`Success: ${success}`);\n     *         if (error) {\n     *             console.log(`Error: ${error}`);\n     *         }\n     *     });\n     * });\n     * ```\n     */\n    downloadPreloadScripts(scripts) {\n        return this.wire.sendAction('download-preload-scripts', { scripts }).then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves an array of data (name, ids, bounds) for all application windows.\n     *\n     * @example\n     * ```js\n     * fin.System.getAllExternalApplications()\n     * .then(externalApps => console.log('Total external apps: ' + externalApps.length))\n     * .catch(err => console.log(err));\n     * ```\n     */\n    getAllExternalApplications() {\n        return this.wire.sendAction('get-all-external-applications').then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves app asset information.\n     * @param options\n     *\n     * @example\n     * ```js\n     * fin.System.getAppAssetInfo({alias:'procexp'}).then(assetInfo => console.log(assetInfo)).catch(err => console.log(err));\n     * ```\n     */\n    getAppAssetInfo(options) {\n        return this.wire.sendAction('get-app-asset-info', options).then(({ payload }) => payload.data);\n    }\n    /**\n     * Get additional info of cookies.\n     *\n     * @example\n     * ```js\n     * fin.System.getCookies({name: 'myCookie'}).then(cookies => console.log(cookies)).catch(err => console.log(err));\n     * ```\n     */\n    getCookies(options) {\n        const url = this.wire.environment.getUrl();\n        const newOptions = Object.assign(options, { url });\n        return this.wire.sendAction('get-cookies', newOptions).then(({ payload }) => payload.data);\n    }\n    /**\n     * Set the minimum log level above which logs will be written to the OpenFin log\n     * @param The minimum level (inclusive) above which all calls to log will be written\n     *\n     * @example\n     * ```js\n     * fin.System.setMinLogLevel(\"verbose\").then(() => console.log(\"log level is set to verbose\")).catch(err => console.log(err));\n     * ```\n     */\n    setMinLogLevel(level) {\n        return this.wire.sendAction('set-min-log-level', { level }).then(() => undefined);\n    }\n    /**\n     * Retrieves the UUID of the computer on which the runtime is installed\n     * @param uuid The uuid of the running application\n     *\n     * @example\n     * ```js\n     * fin.System.resolveUuid('OpenfinPOC').then(entity => console.log(entity)).catch(err => console.log(err));\n     * ```\n     */\n    resolveUuid(uuid) {\n        return this.wire\n            .sendAction('resolve-uuid', {\n            entityKey: uuid\n        })\n            .then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves an array of data for all external applications\n     * @param requestingIdentity This object is described in the Identity typedef\n     * @param data Any data type to pass to the method\n     *\n     * @ignore\n     */\n    executeOnRemote(requestingIdentity, data) {\n        data.requestingIdentity = requestingIdentity;\n        return this.wire.ferryAction(data);\n    }\n    /**\n     * Reads the specifed value from the registry.\n     * @remarks This method is restricted by default and must be enabled via\n     * [API security settings](https://developers.openfin.co/docs/api-security).\n     * @param rootKey - The registry root key.\n     * @param subkey - The registry key.\n     * @param value - The registry value name.\n     *\n     * @example\n     * ```js\n     * fin.System.readRegistryValue(\"HKEY_LOCAL_MACHINE\", \"HARDWARE\\\\DESCRIPTION\\\\System\", \"BootArchitecture\").then(val => console.log(val)).catch(err => console.log(err));\n     * ```\n     *\n     * See {@link https://msdn.microsoft.com/en-us/library/windows/desktop/ms681382(v=vs.85).aspx here} for Window's error code definitions.\n     *\n     * Example payloads of different registry types:\n     *\n     * See list of types {@link https://msdn.microsoft.com/en-us/library/windows/desktop/ms724884(v=vs.85).aspx here}.\n     *\n     * ```js\n     * // REG_DWORD\n     * {\n     *     data: 1,\n     *     rootKey: \"HKEY_LOCAL_MACHINE\",\n     *     subkey: \"Foo\\Bar\",\n     *     type: \"REG_DWORD\",\n     *     value: \"Baz\"\n     * }\n     *\n     * // REG_QWORD\n     * {\n     *     data: 13108146671334112,\n     *     rootKey: \"HKEY_LOCAL_MACHINE\",\n     *     subkey: \"Foo\\Bar\",\n     *     type: \"REG_QWORD\",\n     *     value: \"Baz\"\n     * }\n     *\n     * // REG_SZ\n     * {\n     *     data: \"FooBarBaz\",\n     *     rootKey: \"HKEY_LOCAL_MACHINE\",\n     *     subkey: \"Foo\\Bar\",\n     *     type: \"REG_SZ\",\n     *     value: \"Baz\"\n     * }\n     *\n     * // REG_EXPAND_SZ\n     * {\n     *     data: \"C:\\User\\JohnDoe\\AppData\\Local\",\n     *     rootKey: \"HKEY_CURRENT_USER\",\n     *     subkey: \"Foo\\Bar\",\n     *     type: \"REG_EXPAND_SZ\",\n     *     value: \"Baz\"\n     * }\n     *\n     * // REG_MULTI_SZ\n     * {\n     *     data: [\n     *         \"Foo\",\n     *         \"Bar\",\n     *         \"Baz\"\n     *     ],\n     *     rootKey: \"HKEY_CURRENT_USER\",\n     *     subkey: \"Foo\\Bar\",\n     *     type: \"REG_MULTI_SZ\",\n     *     value: \"Baz\"\n     * }\n     *\n     * // REG_BINARY\n     * {\n     *     data: {\n     *         data: [\n     *             255,\n     *             255,\n     *             0,\n     *             43,\n     *             55,\n     *             0,\n     *             0,\n     *             255,\n     *             255\n     *         ],\n     *         type: \"Buffer\"\n     *     },\n     *     rootKey: \"HKEY_CURRENT_USER\",\n     *     subkey: \"Foo\\Bar\",\n     *     type: \"REG_BINARY\",\n     *     value: \"Baz\"\n     * }\n     * ```\n     */\n    readRegistryValue(rootKey, subkey, value) {\n        return this.wire\n            .sendAction('read-registry-value', {\n            rootKey,\n            subkey,\n            value\n        })\n            .then(({ payload }) => payload.data);\n    }\n    /**\n     * This function call will register a unique id and produce a token.\n     * The token can be used to broker an external connection.\n     * @param uuid - A UUID for the remote connection.\n     *\n     * @example\n     * ```js\n     * fin.System.registerExternalConnection(\"remote-connection-uuid\").then(conn => console.log(conn)).catch(err => console.log(err));\n     *\n     *\n     * // object comes back with\n     * //     token: \"0489EAC5-6404-4F0D-993B-92BB8EAB445D\", // this will be unique each time\n     * //     uuid: \"remote-connection-uuid\"\n     *\n     * ```\n     */\n    registerExternalConnection(uuid) {\n        return this.wire.sendAction('register-external-connection', { uuid }).then(({ payload }) => payload.data);\n    }\n    /**\n     * Returns the json blob found in the [desktop owner settings](https://openfin.co/documentation/desktop-owner-settings/)\n     * for the specified service.\n     * @param serviceIdentifier An object containing a name key that identifies the service.\n     *\n     * @remarks More information about desktop services can be found [here](https://developers.openfin.co/docs/desktop-services).\n     * This call will reject if the desktop owner settings file is not present, not correctly formatted, or if the service requested is not configured or configured incorrectly.\n     *\n     * @example\n     * ```js\n     * // Here we are using the [layouts](https://github.com/HadoukenIO/layouts-service) service.\n     * fin.System.getServiceConfiguration({name:'layouts'}).then(console.log).catch(console.error);\n     * ```\n     */\n    async getServiceConfiguration(serviceIdentifier) {\n        if (typeof serviceIdentifier.name !== 'string') {\n            throw new Error('Must provide an object with a `name` property having a string value');\n        }\n        const { name } = serviceIdentifier;\n        return this.wire.sendAction('get-service-configuration', { name }).then(({ payload }) => payload.data);\n    }\n    async getSystemAppConfig(name) {\n        if (typeof name !== 'string') {\n            throw new Error('Must provide a string value for name of system app');\n        }\n        return this.wire.sendAction('get-system-app-configuration', { name }).then(({ payload }) => payload.data);\n    }\n    /**\n     * Registers a system shutdown handler so user can do some cleanup before system is shutting down.\n     * @remarks Once system shutdown starts, you are unable to cancel it.\n     * @param handler system shutdown handler\n     *\n     * @example\n     * ```js\n     * fin.System.registerShutdownHandler((shutdownEvent) => {\n     *         // save state or cleanup\n     *         console.log('do some cleanup before shutdown');\n     *         // Notify app is ready for termination.\n     *         shutdownEvent.proceed();\n     * })\n     * .then(() => console.log('Shutdown handler registered!'))\n     * .catch(err => console.log(err));\n     * ```\n     * @experimental\n     */\n    async registerShutdownHandler(handler) {\n        this.wire.sendAction('system-register-shutdown-handler').catch((e) => {\n            // don't expose, analytics-only call\n        });\n        const SystemShutdownEventName = 'system-shutdown';\n        const SystemShutdownHandledEventName = 'system-shutdown-handled';\n        const { uuid, name } = this.wire.me;\n        const shutdownHandler = (payload) => {\n            const proceed = () => {\n                // notify core that the app is ready for shutdown\n                this.wire.environment.raiseEvent(`application/${SystemShutdownHandledEventName}`, {\n                    uuid,\n                    name,\n                    topic: 'application'\n                });\n            };\n            handler({ proceed });\n        };\n        this.on(SystemShutdownEventName, shutdownHandler);\n    }\n    /**\n     * Signals the RVM to perform a health check and returns the results as json.\n     *\n     * @remarks Requires RVM 5.5+\n     *\n     * @example\n     * ```js\n     * try {\n     *     const results = await fin.System.runRvmHealthCheck();\n     *     console.log(results);\n     * } catch(e) {\n     *      console.error(e);\n     * }\n     * ```\n     */\n    runRvmHealthCheck() {\n        return this.wire.sendAction('run-rvm-health-check').then(({ payload }) => payload.data);\n    }\n    /**\n     * Launch application using a manifest URL/path. It differs from Application.startFromManifest in that this API can accept a manifest using the fin protocol.\n     * @param manifestUrl - The manifest's URL or path.\n     * @param opts - Parameters that the RVM will use.\n     *\n     * @experimental\n     * @remarks Supports protocols http/s and fin/s, and also a local path.\n     *\n     * Note: This API is Windows only.\n     *\n     * @example\n     *\n     * This API can handle most manifest types. Some examples below.\n     *\n     * Traditional:\n     * ```js\n     * const manifest = await fin.System.launchManifest(\n     *   'https://demoappdirectory.openf.in/desktop/config/apps/OpenFin/HelloOpenFin/app.json');\n     * console.log(manifest);\n     * ```\n     *\n     * Platform:\n     * ```js\n     * const manifest = await fin.System.launchManifest('https://openfin.github.io/platform-api-project-seed/public.json');\n     * console.log(manifest);\n     * ```\n     *\n     * Launching traditional manifest into a platform:\n     * ```js\n     * const manifest = await fin.System.launchManifest(\n     *   'https://openfin.github.io/platform-api-project-seed/public.json?\\\n     *   $$appManifestUrl=https://demoappdirectory.openf.in/desktop/config/\\\n     *   apps/OpenFin/HelloOpenFin/app.json');\n     * console.log(manifest);\n     * ```\n     *\n     * Launching with RVM options:\n     * ```js\n     * const manifest = await fin.System.launchManifest('https://openfin.github.io/platform-api-project-seed/public.json',\n     *     { noUi: true, userAppConfigArgs: { abc: '123', xyz: '789' } });\n     * console.log(manifest);\n     * ```\n     *\n     * Local Path:\n     * ```js\n     * const manifest =  await fin.System.launchManifest('file://c:\\\\path\\\\to\\\\manifest\\\\file.json');\n     * console.log(manifest);\n     * ```\n     *\n     * Launching with RVM 'subscribe' option:\n     *\n     * This option allows users to subscribe to app version resolver events when\n     * calling launchManifest with fallbackManifests specified.\n     *\n     * ```js\n     * fin.System.launchManifest('fins://system-apps/notifications/app.json', { subscribe: (launch) => {\n     * \t\tlaunch.on('app-version-progress', (progress) => {\n     * \t\t\tconsole.log(\"Trying manifest \" + progress.manifest)\n     * \t\t});\n     *\n     * \t\tlaunch.on('runtime-status', (status) => {\n     * \t\t\tconsole.log(\"Runtime status: \" + JSON.stringify(status));\n     * \t\t});\n     *\n     * \t\t// RVM has successfully found the target runtime version\n     * \t\tlaunch.on('app-version-complete', (complete) => {\n     * \t\t\tconsole.log(\"Parent app \" + complete.srcManifest + \" resolved to \" + complete.manifest);\n     * \t\t\tlaunch.removeAllListeners();\n     * \t\t});\n     *\n     * \t\t// RVM failed to find an available runtime version\n     * \t\tlaunch.on('app-version-error', (error) => {\n     * \t\t\tconsole.log(\"Failed to resolve \" + error.srcManifest + \" from the fallbackManifests\");\n     * \t\t\tlaunch.removeAllListeners();\n     * \t\t});\n     * \t}\n     * });\n     * ```\n     */\n    async launchManifest(manifestUrl, opts = {}) {\n        const { subscribe, ..._sendOpts } = opts;\n        const sendOpts = _sendOpts;\n        if (subscribe) {\n            const launchEmitter = new events_1$6.EventEmitter();\n            subscribe(launchEmitter);\n            const AppVersionProgressEventName = 'app-version-progress';\n            const RuntimeStatusEventName = 'runtime-status';\n            const AppVersionCompleteEventName = 'app-version-complete';\n            const AppVersionErrorEventName = 'app-version-error';\n            // add id to avoid multiple api calls getting duplicated events\n            const id = this.wire.environment.getNextMessageId().toString();\n            sendOpts.appVersionId = id;\n            const supportedEvents = [\n                AppVersionCompleteEventName,\n                AppVersionProgressEventName,\n                RuntimeStatusEventName,\n                AppVersionErrorEventName\n            ];\n            const cleanEventPayload = (payload) => {\n                // We need to do type castings below to make sure the return type is correct.\n                const { appVersionId, topic, type: typeWithId, ...rest } = payload;\n                const type = supportedEvents.find((x) => typeWithId.includes(x));\n                return {\n                    ...rest,\n                    type\n                };\n            };\n            const appVersionListener = (payload) => {\n                const cleanPayload = cleanEventPayload(payload);\n                launchEmitter.emit(cleanPayload.type, cleanPayload);\n            };\n            const removeAllListeners = () => {\n                this.removeListener(`${AppVersionProgressEventName}.${id}`, appVersionListener);\n                this.removeListener(`${RuntimeStatusEventName}.${id}`, appVersionListener);\n                this.removeListener(`${AppVersionCompleteEventName}.${id}`, appVersionListener);\n                this.removeListener(`${AppVersionErrorEventName}.${id}`, appVersionListener);\n                this.removeListener(`${AppVersionCompleteEventName}.${id}`, removeAllListeners);\n                this.removeListener(`${AppVersionErrorEventName}.${id}`, removeAllListeners);\n            };\n            await Promise.all([\n                this.on(`${AppVersionProgressEventName}.${id}`, appVersionListener),\n                this.on(`${RuntimeStatusEventName}.${id}`, appVersionListener),\n                this.once(`${AppVersionCompleteEventName}.${id}`, appVersionListener),\n                this.once(`${AppVersionErrorEventName}.${id}`, appVersionListener),\n                this.once(`${AppVersionCompleteEventName}.${id}`, removeAllListeners),\n                this.once(`${AppVersionErrorEventName}.${id}`, removeAllListeners)\n            ]);\n        }\n        const response = await this.wire.sendAction('launch-manifest', {\n            manifestUrl,\n            opts: sendOpts\n        });\n        return response.payload.data.manifest;\n    }\n    /**\n     * Query permission of a secured api in current context.\n     *\n     * @param apiName - The full name of a secured API.\n     *\n     * @remarks If a function has a structured permission value, the value of `granted` will reflect the `enabled` key\n     * of the call's permissions literal.  In this case, *permission may still be denied to a call* pending arguments or other\n     * runtime state.  This is indicated with `state: unavailable`.\n     *\n     * @example\n     * ```js\n     * fin.System.queryPermissionForCurrentContext('System.launchExternalProcess').then(result => console.log(result)).catch(err => console.log(err));\n     *\n     * //This response has the following shape:\n     * {\n     *    permission: 'System.launchExternalProcess', // api full name\n     *    state: 'granted', // state of permission\n     *    granted: true\n     * }\n     * ```\n     */\n    async queryPermissionForCurrentContext(apiName) {\n        const identity = { uuid: this.wire.me.uuid, name: this.wire.me.name };\n        const response = await this.wire.sendAction('query-permission-for-current-context', {\n            apiName,\n            identity\n        });\n        return response.payload.data;\n    }\n    // Not documenting, internal use only.\n    async enableNativeWindowIntegrationProvider(permissions) {\n        const { payload } = await this.wire.sendAction('enable-native-window-integration-provider', { permissions });\n        return payload.data;\n    }\n    /**\n     * (Internal) Register the usage of a component with a platform\n     * @param options - Object with data and type\n     *\n     * @example\n     * ```js\n     * async function registerUsage() {\n     *     const app = await fin.System.getCurrent();\n     *     return await fin.System.registerUsage({\n     *         type: 'workspace-licensing',\n     *         // example values for the following data object\n     *         data: {\n     *             apiVersion: '1.0',\n     *             componentName: 'home',\n     *             componentVersion: '1.0',\n     *             allowed: true,\n     *             rejectionCode: ''\n     *         }\n     *     });\n     * }\n     *\n     * registerUsage().then(() => console.log('Successfully registered component application')).catch(err => console.log(err));\n     * ```\n     */\n    async registerUsage({ data, type }) {\n        await this.wire.sendAction('register-usage', { data, type });\n    }\n    /**\n     * Returns an array with all printers of the caller and not all the printers on the desktop.\n     *\n     * @example\n     * ```js\n     * fin.System.getPrinters()\n     *     .then((printers) => {\n     *         printers.forEach((printer) => {\n     *             if (printer.isDefault) {\n     *                 console.log(printer);\n     *             }\n     *         });\n     *     })\n     *     .catch((err) => {\n     *         console.log(err);\n     *     });\n     * ```\n     */\n    async getPrinters() {\n        const { payload } = await this.wire.sendAction('system-get-printers');\n        return payload.data;\n    }\n    /**\n     * Updates Process Logging values: periodic interval and outlier detection entries and interval.\n     * @param options Process Logging updatable options.\n     *\n     * @remarks When enabling verbose mode, additional process information is logged to the debug.log:\n     *\n     * 1. Periodically process usage (memory, cpu, etc) will be logged for each PID along with the windows, views and\n     * iframes that belong to them. The default is every 30 seconds. Updatable by passing the interval option.\n     * 2. When Windows and Views are created or navigated the PID they belong to and their options will be logged.\n     * 3. When Windows and Views are destroyed their last known process usage will be logged.\n     * 4. Whenever an outlier memory usage is detected it will be logged. By default, on an interval of 5 seconds we will\n     * collect process usage for all PIDs and when 144 such entries are collected, we will start analyzing the data for any\n     * possible outliers in the following entries. The interval and maximum number of entries stored in the running buffer\n     * can be updatable by passing the outlierDetection.interval and outlierDetection.entries options.\n     *\n     * @example\n     *\n     * ```js\n     * await fin.System.updateProcessLoggingOptions({\n     *     interval: 10,\n     *     outlierDetection: {\n     *         interval: 15,\n     *         entries: 200\n     *     }\n     * });\n     * ```\n     */\n    async updateProcessLoggingOptions(options) {\n        await this.wire.sendAction('system-update-process-logging-options', { options });\n    }\n    /**\n     * Returns domain settings for the current application.\n     * Initial settings are configured with the defaultDomainSettings application option via manifest.\n     * Domain settings can be overwritten during runtime with System.setDomainSettings.\n     * @example\n     * ```js\n     * const domainSettings = await fin.System.getDomainSettings();\n     * // {\n     * //     \"rules\": [\n     * //         {\n     * //             \"match\": [\n     * //                 \"https://openfin.co\"\n     * //             ],\n     * //             \"options\": {\n     * //                 \"downloadSettings\": {\n     * //                     \"rules\": [\n     * //                         {\n     * //                             \"match\": [\n     * //                                 \"<all_urls>\"\n     * //                             ],\n     * //                             \"behavior\": \"prompt\"\n     * //                         }\n     * //                     ]\n     * //                 }\n     * //             }\n     * //         }\n     * //     ]\n     * // }\n     * ```\n     */\n    async getDomainSettings() {\n        const { payload: { data } } = await this.wire.sendAction('get-domain-settings', this.identity);\n        return data;\n    }\n    /**\n     * Sets the domain settings for the current application.\n     * @param domainSettings - domain settings object\n     * @example\n     * ```js\n     * const domainSettings = await fin.System.getDomainSettings();\n     * // {\n     * //     \"rules\": [\n     * //         {\n     * //             \"match\": [\n     * //                 \"https://openfin.co\"\n     * //             ],\n     * //             \"options\": {\n     * //                 \"downloadSettings\": {\n     * //                     \"rules\": [\n     * //                         {\n     * //                             \"match\": [\n     * //                                 \"<all_urls>\"\n     * //                             ],\n     * //                             \"behavior\": \"prompt\"\n     * //                         }\n     * //                     ]\n     * //                 }\n     * //             }\n     * //         }\n     * //     ]\n     * // }\n     *\n     * // Valid rule behaviors are 'prompt' and 'no-prompt'\n     * domainSettings.rules[0].options.downloadSettings.rules[0].behavior = 'no-prompt';\n     *\n     * await fin.System.setDomainSettings(domainSettings);\n     *\n     * const newDomainSettings = await fin.System.getDomainSettings();\n     * // {\n     * //     \"rules\": [\n     * //         {\n     * //             \"match\": [\n     * //                 \"https://openfin.co\"\n     * //             ],\n     * //             \"options\": {\n     * //                 \"downloadSettings\": {\n     * //                     \"rules\": [\n     * //                         {\n     * //                             \"match\": [\n     * //                                 \"<all_urls>\"\n     * //                             ],\n     * //                             \"behavior\": \"no-prompt\"\n     * //                         }\n     * //                     ]\n     * //                 }\n     * //             }\n     * //         }\n     * //     ]\n     * // }\n     * ```\n     */\n    async setDomainSettings(domainSettings) {\n        await this.wire.sendAction('set-domain-settings', { domainSettings, ...this.identity });\n    }\n    /**\n     * Attempts to install and enable extensions for the security realm.  Users may want to call this function in response\n     * to an `extensions-install-failed` event.  Only extensions allowed by every application on the current security realm\n     * will be installed/enabled.\n     */\n    async refreshExtensions() {\n        const { payload } = await this.wire.sendAction('refresh-extensions');\n        return payload.data;\n    }\n    /**\n     * Gets the currently-installed\n     */\n    async getInstalledExtensions() {\n        const { payload } = await this.wire.sendAction('get-installed-extensions');\n        return payload.data;\n    }\n}\nsystem.System = System;\n\nvar interappbus = {};\n\nvar refCounter = {};\n\nObject.defineProperty(refCounter, \"__esModule\", { value: true });\nrefCounter.RefCounter = void 0;\nclass RefCounter {\n    constructor() {\n        this.topicRefMap = new Map();\n    }\n    // returns the ref count after incrementing\n    incRefCount(key) {\n        const refCount = this.topicRefMap.get(key);\n        let returnCount;\n        if (!refCount) {\n            this.topicRefMap.set(key, 1);\n            returnCount = 1;\n        }\n        else {\n            const newRefCount = refCount + 1;\n            returnCount = newRefCount;\n            this.topicRefMap.set(key, newRefCount);\n        }\n        return returnCount;\n    }\n    // returns the ref count after decrementing, or -1 if the key already had no references\n    decRefCount(key) {\n        const refCount = this.topicRefMap.get(key);\n        let returnCount;\n        if (refCount) {\n            const newRefCount = refCount - 1;\n            this.topicRefMap.set(key, newRefCount);\n            returnCount = newRefCount;\n        }\n        else {\n            returnCount = -1;\n        }\n        return returnCount;\n    }\n    // Execute firstAction if it is the first such ref, else execute nonFirstAction.\n    // In either case the return value is that of the action executed\n    actOnFirst(key, firstAction, nonFirstAction) {\n        const numRefs = this.incRefCount(key);\n        const isFirstRef = numRefs === 1;\n        return isFirstRef ? firstAction() : nonFirstAction();\n    }\n    // Execute lastAction if it is the first such ref, else execute nonLastAction.\n    // In either case the return value is that of the action executed\n    actOnLast(key, lastAction, nonLastAction) {\n        const numRefs = this.decRefCount(key);\n        const isLastRef = numRefs === 0;\n        return isLastRef ? lastAction() : nonLastAction();\n    }\n}\nrefCounter.RefCounter = RefCounter;\n\nvar channel$1 = {};\n\nvar client = {};\n\nvar channel = {};\n\nObject.defineProperty(channel, \"__esModule\", { value: true });\nchannel.ChannelBase = channel.ProtectedItems = void 0;\nconst resultOrPayload = (func) => async (topic, payload, senderIdentity) => {\n    const res = await func(topic, payload, senderIdentity);\n    return res === undefined ? payload : res;\n};\nclass ProtectedItems {\n    /**\n     * @internal\n     */\n    // eslint-disable-next-line no-useless-constructor\n    constructor(providerIdentity, close) {\n        this.providerIdentity = providerIdentity;\n        this.close = close;\n    }\n}\nchannel.ProtectedItems = ProtectedItems;\nclass ChannelBase {\n    static defaultAction(topic) {\n        throw new Error(`No action registered at target for ${topic}`);\n    }\n    constructor() {\n        this.subscriptions = new Map();\n    }\n    async processAction(topic, payload, senderIdentity) {\n        try {\n            const mainAction = this.subscriptions.has(topic)\n                ? this.subscriptions.get(topic)\n                : (currentPayload, id) => (this.defaultAction ?? ChannelBase.defaultAction)(topic, currentPayload, id);\n            const preActionProcessed = this.preAction ? await this.preAction(topic, payload, senderIdentity) : payload;\n            const actionProcessed = await mainAction(preActionProcessed, senderIdentity);\n            return this.postAction ? await this.postAction(topic, actionProcessed, senderIdentity) : actionProcessed;\n        }\n        catch (e) {\n            if (this.errorMiddleware) {\n                return this.errorMiddleware(topic, e, senderIdentity);\n            }\n            throw e;\n        }\n    }\n    /**\n     * Register middleware that fires before the action.\n     *\n     * @param func\n     *\n     * @example\n     *\n     * Channel Provider:\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     provider.register('provider-action', (payload, identity) => {\n     *         console.log(payload, identity);\n     *         return {\n     *             echo: payload\n     *         };\n     *     });\n     *\n     *     provider.beforeAction((action, payload, identity) => {\n     *         //The payload can be altered here before handling the action.\n     *         payload.received = Date.now();\n     *         return payload;\n     *     });\n     *\n     * })();\n     * ```\n     *\n     * Channel Client:\n     * ```js\n     * (async ()=> {\n     *     const client = await fin.InterApplicationBus.Channel.connect('channelName');\n     *\n     *     client.register('client-action', (payload, identity) => {\n     *         console.log(payload, identity);\n     *         return {\n     *             echo: payload\n     *         };\n     *     });\n     *\n     *     client.beforeAction((action, payload, identity) => {\n     *         //The payload can be altered here before handling the action.\n     *         payload.received = Date.now();\n     *         return payload;\n     *     });\n     *\n     *     const providerResponse = await client.dispatch('provider-action', { message: 'Hello From the client' });\n     *     console.log(providerResponse);\n     * })();\n     * ```\n     */\n    beforeAction(func) {\n        if (this.preAction) {\n            throw new Error('Already registered beforeAction middleware');\n        }\n        this.preAction = resultOrPayload(func);\n    }\n    /**\n     * Register an error handler. This is called before responding on any error.\n     *\n     * @param func\n     *\n     * Channel Provider:\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     provider.register('provider-action', (payload, identity) => {\n     *         console.log(payload);\n     *         throw new Error('Action error');\n     *         return {\n     *             echo: payload\n     *         };\n     *     });\n     *\n     *     provider.onError((action, error, identity) => {\n     *         console.log('uncaught Exception in action:', action);\n     *         console.error(error);\n     *     });\n     *\n     * })();\n     * ```\n     *\n     * Channel Client:\n     * ```js\n     * (async ()=> {\n     *     const client = await fin.InterApplicationBus.Channel.connect('channelName');\n     *\n     *     client.register('client-action', (payload, identity) => {\n     *         console.log(payload);\n     *         throw new Error('Action error');\n     *         return {\n     *             echo: payload\n     *         };\n     *     });\n     *\n     *     client.onError((action, error, identity) => {\n     *         console.log('uncaught Exception in action:', action);\n     *         console.error(error);\n     *     });\n     * })();\n     * ```\n     */\n    onError(func) {\n        if (this.errorMiddleware) {\n            throw new Error('Already registered error middleware');\n        }\n        this.errorMiddleware = func;\n    }\n    /**\n     * Register middleware that fires after the action.\n     *\n     * @param func\n     *\n     * @remarks If the action does not return the payload, then the afterAction will not have access to the payload object.\n     *\n     * @example\n     *\n     * Channel Provider:\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     await provider.register('provider-action', (payload, identity) => {\n     *         return {\n     *             echo: payload\n     *         };\n     *     });\n     *\n     *     await provider.afterAction((action, payload, identity) => {\n     *         //the payload can be altered here after handling the action but before sending an acknowledgement.\n     *         payload.sent = date.now();\n     *         return payload;\n     *     });\n     *\n     * })();\n     * ```\n     *\n     * Channel Client:\n     * ```js\n     * (async ()=> {\n     *     const client = await fin.InterApplicationBus.Channel.connect('channelName');\n     *\n     *     await client.register('client-action', (payload, identity) => {\n     *         return {\n     *             echo: payload\n     *         };\n     *     });\n     *\n     *     await client.afterAction((action, payload, identity) => {\n     *         //the payload can be altered here after handling the action but before sending an acknowledgement.\n     *         payload.sent = date.now();\n     *         return payload;\n     *     });\n     *\n     * })();\n     * ```\n     */\n    afterAction(func) {\n        if (this.postAction) {\n            throw new Error('Already registered afterAction middleware');\n        }\n        this.postAction = resultOrPayload(func);\n    }\n    /**\n     * Remove an action by action name.\n     *\n     * @param action\n     *\n     * @example\n     *\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     await provider.register('provider-action', (payload, identity) => {\n     *         console.log(payload);\n     *         return {\n     *             echo: payload\n     *         };\n     *     });\n     *\n     *     await provider.remove('provider-action');\n     *\n     * })();\n     * ```\n     */\n    remove(action) {\n        this.subscriptions.delete(action);\n    }\n    /**\n     * Registers a default action. This is used any time an action that has not been registered is invoked.\n     *\n     * @example\n     *\n     * Channel Provider:\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     await provider.setDefaultAction((action, payload, identity) => {\n     *         console.log(`Client with identity ${JSON.stringify(identity)} has attempted to dispatch unregistered action: ${action}.`);\n     *\n     *         return {\n     *             echo: payload\n     *         };\n     *     });\n     *\n     * })();\n     * ```\n     *\n     * Channel Client:\n     * ```js\n     * (async ()=> {\n     *     const client = await fin.InterApplicationBus.Channel.connect('channelName');\n     *\n     *     await client.setDefaultAction((action, payload, identity) => {\n     *         console.log(`Provider with identity ${JSON.stringify(identity)} has attempted to dispatch unregistered action: ${action}.`);\n     *\n     *         return {\n     *             echo: payload\n     *         };\n     *     });\n     *\n     * })();\n     * ```\n     * @param func\n     */\n    setDefaultAction(func) {\n        if (this.defaultAction) {\n            throw new Error('default action can only be set once');\n        }\n        else {\n            this.defaultAction = func;\n        }\n    }\n    /**\n     * Register an action to be called by dispatching from any channelClient or channelProvider.\n     *\n     * @param topic\n     * @param listener\n     *\n     * @remarks The return value will be sent back as an acknowledgement to the original caller. You can throw an\n     * error to send a negative-acknowledgement and the error will reject the promise returned to the sender by the\n     * dispatch call.  Once a listener is registered for a particular action, it stays in place receiving and responding\n     * to incoming messages until it is removed.  This messaging mechanism works exactly the same when messages are\n     * dispatched from the provider to a client.  However, the provider has an additional publish method that sends messages\n     * to all connected clients.\n     *\n     * Because multiple clients can share the same `name` and `uuid`, in order to distinguish between individual clients,\n     * the `identity` argument in a provider's registered action callback contains an `endpointId` property. When dispatching\n     * from a provider to a client, the `endpointId` property must be provided in order to send an action to a specific client.\n     *\n     * @example\n     *\n     * Channel Provider:\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     await provider.register('provider-action', (payload, identity) => {\n     *        console.log('Action dispatched by client: ', identity);\n     *        console.log('Payload sent in dispatch: ', payload);\n     *\n     *        return { echo: payload };\n     *    });\n     * })();\n     * ```\n     *\n     * Channel Client:\n     * ```js\n     * (async ()=> {\n     *     const client = await fin.InterApplicationBus.Channel.connect('channelName');\n     *\n     *     await client.register('client-action', (payload, identity) => {\n     *        console.log('Action dispatched by client: ', identity);\n     *        console.log('Payload sent in dispatch: ', payload);\n     *\n     *        return { echo: payload };\n     *    });\n     * })();\n     * ```\n     */\n    register(topic, listener) {\n        if (this.subscriptions.has(topic)) {\n            throw new Error(`Subscription already registered for action: ${topic}. Unsubscribe before adding new subscription`);\n        }\n        else {\n            this.subscriptions.set(topic, listener);\n            return true;\n        }\n    }\n}\nchannel.ChannelBase = ChannelBase;\n\nvar __classPrivateFieldGet$c = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar __classPrivateFieldSet$a = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar _ChannelClient_protectedObj, _ChannelClient_strategy, _ChannelClient_close;\nObject.defineProperty(client, \"__esModule\", { value: true });\nclient.ChannelClient = void 0;\nconst channel_1$1 = channel;\nconst channelClientsByEndpointId = new Map();\n/**\n * Instance created to enable use of a channel as a client.  Allows for communication with the\n * {@link ChannelProvider ChannelProvider} by invoking an action on the\n * provider via {@link ChannelClient#dispatch dispatch} and to listen for communication\n * from the provider by registering an action via {@link ChannelClient#register register}.\n *\n * ### Synchronous Methods:\n *  * {@link ChannelClient#onDisconnection onDisconnection(listener)}\n *  * {@link ChannelClient#register register(action, listener)}\n *  * {@link ChannelClient#remove remove(action)}\n *\n * ### Asynchronous Methods:\n *  * {@link ChannelClient#disconnect disconnect()}\n *  * {@link ChannelClient#dispatch dispatch(action, payload)}\n *\n * ### Middleware:\n * Middleware functions receive the following arguments: (action, payload, senderId).\n * The return value of the middleware function will be passed on as the payload from beforeAction, to the action listener, to afterAction\n * unless it is undefined, in which case the original payload is used.  Middleware can be used for side effects.\n *  * {@link ChannelClient#setDefaultAction setDefaultAction(middleware)}\n *  * {@link ChannelClient#onError onError(middleware)}\n *  * {@link ChannelClient#beforeAction beforeAction(middleware)}\n *  * {@link ChannelClient#afterAction afterAction(middleware)}\n */\nclass ChannelClient extends channel_1$1.ChannelBase {\n    /**\n     * @internal\n     */\n    static closeChannelByEndpointId(id) {\n        const channel = channelClientsByEndpointId.get(id);\n        if (channel) {\n            __classPrivateFieldGet$c(channel, _ChannelClient_close, \"f\").call(channel);\n        }\n    }\n    /**\n     * @internal\n     * closes the corresponding channel and invokes the disconnect listener if an event payload is passed.\n     */\n    static handleProviderDisconnect(eventPayload) {\n        for (const channelClient of channelClientsByEndpointId.values()) {\n            if (channelClient.providerIdentity.channelId === eventPayload.channelId) {\n                channelClient.disconnectListener(eventPayload);\n                __classPrivateFieldGet$c(channelClient, _ChannelClient_close, \"f\").call(channelClient);\n            }\n        }\n    }\n    /**\n     * @internal\n     */\n    constructor(routingInfo, close, strategy) {\n        super();\n        _ChannelClient_protectedObj.set(this, void 0);\n        _ChannelClient_strategy.set(this, void 0);\n        // needs to be bound;\n        this.processAction = (action, payload, senderIdentity) => super.processAction(action, payload, senderIdentity);\n        _ChannelClient_close.set(this, () => {\n            channelClientsByEndpointId.delete(this.endpointId);\n            __classPrivateFieldGet$c(this, _ChannelClient_strategy, \"f\").close();\n        });\n        __classPrivateFieldSet$a(this, _ChannelClient_protectedObj, new channel_1$1.ProtectedItems(routingInfo, close), \"f\");\n        this.disconnectListener = () => undefined;\n        this.endpointId = routingInfo.endpointId;\n        __classPrivateFieldSet$a(this, _ChannelClient_strategy, strategy, \"f\");\n        channelClientsByEndpointId.set(this.endpointId, this);\n        strategy.receive(this.processAction);\n    }\n    /**\n     * a read-only provider identity\n     */\n    get providerIdentity() {\n        const protectedObj = __classPrivateFieldGet$c(this, _ChannelClient_protectedObj, \"f\");\n        return protectedObj.providerIdentity;\n    }\n    /**\n     * Dispatch the given action to the channel provider. Returns a promise that resolves with the response from\n     * the provider for that action.\n     *\n     * @param action\n     * @param payload\n     *\n     * @example\n     *\n     * ```js\n     * (async ()=> {\n     *     const client = await fin.InterApplicationBus.Channel.connect('channelName');\n     *\n     *     await client.register('client-action', (payload, identity) => {\n     *         console.log(payload, identity);\n     *         return {\n     *             echo: payload\n     *         };\n     *     });\n     *\n     *     const providerResponse = await client.dispatch('provider-action', { message: 'Hello From the client'});\n     *     console.log(providerResponse);\n     * })();\n     * ```\n     */\n    async dispatch(action, payload) {\n        if (__classPrivateFieldGet$c(this, _ChannelClient_strategy, \"f\").isEndpointConnected(this.providerIdentity.channelId)) {\n            return __classPrivateFieldGet$c(this, _ChannelClient_strategy, \"f\").send(this.providerIdentity.channelId, action, payload);\n        }\n        throw new Error('The client you are trying to dispatch from is disconnected from the target provider.');\n    }\n    /**\n     * Register a listener that is called on provider disconnection. It is passed the disconnection event of the\n     * disconnecting provider.\n     *\n     * @param listener\n     *\n     * @example\n     *\n     * ```js\n     * (async ()=> {\n     *     const client = await fin.InterApplicationBus.Channel.connect('channelName');\n     *\n     *     await client.onDisconnection(evt => {\n     *         console.log('Provider disconnected', `uuid: ${evt.uuid}, name: ${evt.name}`);\n     *     });\n     * })();\n     * ```\n     */\n    onDisconnection(listener) {\n        this.disconnectListener = (payload) => {\n            try {\n                listener(payload);\n            }\n            catch (err) {\n                throw new Error(`Error while calling the onDisconnection callback: ${err.message}`);\n            }\n            finally {\n                this.disconnectListener = () => undefined;\n            }\n        };\n    }\n    /**\n     * Disconnects the client from the channel.\n     *\n     * @example\n     *\n     * ```js\n     * (async ()=> {\n     *     const client = await fin.InterApplicationBus.Channel.connect('channelName');\n     *\n     *     await client.disconnect();\n     * })();\n     * ```\n     */\n    async disconnect() {\n        await this.sendDisconnectAction();\n        __classPrivateFieldGet$c(this, _ChannelClient_close, \"f\").call(this);\n    }\n    async sendDisconnectAction() {\n        const protectedObj = __classPrivateFieldGet$c(this, _ChannelClient_protectedObj, \"f\");\n        await protectedObj.close();\n    }\n    /**\n     * @internal\n     * Writing this as a static to keep code together, but in environments with a wire, this will be DI'd into the protectedObject class as close.\n     */\n    static async wireClose(wire, providerIdentity, endpointId) {\n        const { channelName, uuid, name } = providerIdentity;\n        await wire.sendAction('disconnect-from-channel', {\n            channelName,\n            uuid,\n            name,\n            endpointId\n        });\n    }\n}\nclient.ChannelClient = ChannelClient;\n_ChannelClient_protectedObj = new WeakMap(), _ChannelClient_strategy = new WeakMap(), _ChannelClient_close = new WeakMap();\n\nvar connectionManager = {};\n\nvar exhaustive = {};\n\nObject.defineProperty(exhaustive, \"__esModule\", { value: true });\nexhaustive.exhaustiveCheck = void 0;\nfunction exhaustiveCheck(value, allowed) {\n    throw new Error(`Unsupported value: ${value}${allowed ? `\\n Supported values are: ${allowed.join('')}` : ''}`);\n}\nexhaustive.exhaustiveCheck = exhaustiveCheck;\n\nvar strategy$3 = {};\n\nvar __classPrivateFieldSet$9 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar __classPrivateFieldGet$b = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar _ClassicStrategy_wire, _ClassicStrategy_endpointIdentityMap, _ClassicStrategy_pendingMessagesByEndpointId;\nObject.defineProperty(strategy$3, \"__esModule\", { value: true });\nstrategy$3.ClassicInfo = strategy$3.ClassicStrategy = void 0;\n/*\nThis is used to abstract out ipc messaging from the channels implementation. It is only concerned with sending messages and registration with the MessageReceiver\n*/\nclass ClassicStrategy {\n    constructor(wire, messageReceiver, endpointId, // Provider endpointId is channelId\n    providerIdentity) {\n        this.messageReceiver = messageReceiver;\n        this.endpointId = endpointId;\n        this.providerIdentity = providerIdentity;\n        _ClassicStrategy_wire.set(this, void 0);\n        // Store full endpointIdentity by endpointId of all known endpoints for this strategy instance.\n        // (clients will only have 1: the provider, the provider will have all clients)\n        _ClassicStrategy_endpointIdentityMap.set(this, new Map());\n        // Store a set of cancellable promises to be able to reject them when client\n        // connection problems occur\n        _ClassicStrategy_pendingMessagesByEndpointId.set(this, new Map);\n        this.send = async (endpointId, action, payload) => {\n            const to = __classPrivateFieldGet$b(this, _ClassicStrategy_endpointIdentityMap, \"f\").get(endpointId);\n            if (!to) {\n                throw new Error(`Could not locate routing info for endpoint ${endpointId}`);\n            }\n            // as casting to any because typescript complains. The following is only relevant if this is a locally set endpointId on a ClientIdentity.\n            // We delete these properties to not change backwards compatibility.\n            const cleanId = { ...to };\n            if (cleanId.isLocalEndpointId) {\n                delete cleanId.endpointId;\n            }\n            delete cleanId.isLocalEndpointId;\n            // grab the promise before awaiting it to save in our pending messages map\n            const p = __classPrivateFieldGet$b(this, _ClassicStrategy_wire, \"f\")\n                .sendAction('send-channel-message', {\n                ...cleanId,\n                providerIdentity: this.providerIdentity,\n                action,\n                payload\n            });\n            __classPrivateFieldGet$b(this, _ClassicStrategy_pendingMessagesByEndpointId, \"f\").get(endpointId)?.add(p);\n            const raw = await p.catch((error) => {\n                throw new Error(error.message);\n            }).finally(() => {\n                // clean up the pending promise\n                __classPrivateFieldGet$b(this, _ClassicStrategy_pendingMessagesByEndpointId, \"f\").get(endpointId)?.delete(p);\n            });\n            return raw.payload.data.result;\n        };\n        this.close = async () => {\n            this.messageReceiver.removeEndpoint(this.providerIdentity.channelId, this.endpointId);\n            [...__classPrivateFieldGet$b(this, _ClassicStrategy_endpointIdentityMap, \"f\").keys()].forEach((id) => this.closeEndpoint(id));\n            __classPrivateFieldSet$9(this, _ClassicStrategy_endpointIdentityMap, new Map(), \"f\");\n        };\n        __classPrivateFieldSet$9(this, _ClassicStrategy_wire, wire, \"f\");\n    }\n    onEndpointDisconnect(endpointId, listener) {\n        // Never fires for 'classic'.\n    }\n    receive(listener) {\n        this.messageReceiver.addEndpoint(listener, this.providerIdentity.channelId, this.endpointId);\n    }\n    async closeEndpoint(endpointId) {\n        const id = __classPrivateFieldGet$b(this, _ClassicStrategy_endpointIdentityMap, \"f\").get(endpointId);\n        __classPrivateFieldGet$b(this, _ClassicStrategy_endpointIdentityMap, \"f\").delete(endpointId);\n        const pendingSet = __classPrivateFieldGet$b(this, _ClassicStrategy_pendingMessagesByEndpointId, \"f\").get(endpointId);\n        pendingSet?.forEach((p) => {\n            const errorMsg = `Channel connection with identity uuid: ${id?.uuid} / name: ${id?.name} / endpointId: ${endpointId} no longer connected.`;\n            p.cancel(new Error(errorMsg));\n        });\n    }\n    isEndpointConnected(endpointId) {\n        return __classPrivateFieldGet$b(this, _ClassicStrategy_endpointIdentityMap, \"f\").has(endpointId);\n    }\n    addEndpoint(endpointId, payload) {\n        __classPrivateFieldGet$b(this, _ClassicStrategy_endpointIdentityMap, \"f\").set(endpointId, payload.endpointIdentity);\n        __classPrivateFieldGet$b(this, _ClassicStrategy_pendingMessagesByEndpointId, \"f\").set(endpointId, new Set());\n    }\n    isValidEndpointPayload(payload) {\n        return (typeof payload?.endpointIdentity?.endpointId === 'string' ||\n            typeof payload?.endpointIdentity?.channelId === 'string');\n    }\n}\nstrategy$3.ClassicStrategy = ClassicStrategy;\n_ClassicStrategy_wire = new WeakMap(), _ClassicStrategy_endpointIdentityMap = new WeakMap(), _ClassicStrategy_pendingMessagesByEndpointId = new WeakMap();\n// Arbitrarily starting at 5 to leave the door open to backfilling pre endpointId etc.\nstrategy$3.ClassicInfo = { version: 5, minimumVersion: 0, type: 'classic' };\n\nvar strategy$2 = {};\n\nvar endpoint = {};\n\nvar errors = {};\n\nObject.defineProperty(errors, \"__esModule\", { value: true });\nerrors.errorToPOJO = void 0;\nfunction errorToPOJO(error) {\n    return {\n        stack: error.stack,\n        name: error.name,\n        message: error.message,\n        // support the case where stack is empty or missing\n        toString: () => error.stack || error.toString()\n    };\n}\nerrors.errorToPOJO = errorToPOJO;\n\nvar __classPrivateFieldGet$a = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar __classPrivateFieldSet$8 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar _RTCEndpoint_processAction, _RTCEndpoint_disconnectListener;\nObject.defineProperty(endpoint, \"__esModule\", { value: true });\nendpoint.RTCEndpoint = void 0;\n/* eslint-disable @typescript-eslint/no-unused-vars */\nconst errors_1$1 = errors;\n/*\nThis handles sending RTC messages between RTC connections over the request and response data channels.\n*/\nclass RTCEndpoint {\n    static isValidEndpointPayload(payload) {\n        const isObject = (x) => {\n            return typeof x === 'object' && x !== null;\n        };\n        return (\n        // TODO in factory PR:\n        // payload.type === 'rtc' &&\n        isObject(payload) &&\n            isObject(payload.endpointIdentity) &&\n            isObject(payload.rtc) &&\n            typeof payload.endpointIdentity.endpointId === 'string');\n    }\n    constructor({ rtc, endpointIdentity }) {\n        this.responseMap = new Map();\n        _RTCEndpoint_processAction.set(this, null);\n        _RTCEndpoint_disconnectListener.set(this, void 0);\n        this.connectionStateChangeHandler = (event) => {\n            if (this.rtc.rtcClient.connectionState !== 'connected') {\n                this.rtc.rtcClient.removeEventListener('connectionstatechange', this.connectionStateChangeHandler);\n                this.close();\n                if (__classPrivateFieldGet$a(this, _RTCEndpoint_disconnectListener, \"f\")) {\n                    __classPrivateFieldGet$a(this, _RTCEndpoint_disconnectListener, \"f\").call(this);\n                }\n            }\n        };\n        this.send = async (action, payload) => {\n            const messageId = `message-${Math.random()}`;\n            const promise = new Promise((resolve, reject) => {\n                this.responseMap.set(messageId, { resolve, reject });\n            });\n            this.rtc.channels.request.send(JSON.stringify({ action, payload, messageId }));\n            return promise;\n        };\n        this.close = () => {\n            this.responseMap.forEach((response) => response.reject('Connection has closed.'));\n            this.responseMap = new Map();\n            this.rtc.channels.request.close();\n            this.rtc.channels.response.close();\n            this.rtc.rtcClient.close();\n        };\n        this.rtc = rtc;\n        this.endpointIdentity = endpointIdentity;\n        this.rtc.channels.response.addEventListener('message', (e) => {\n            let { data } = e;\n            if (e.data instanceof ArrayBuffer) {\n                data = new TextDecoder().decode(e.data);\n            }\n            const { messageId, payload, success, error } = JSON.parse(data);\n            const { resolve, reject } = this.responseMap.get(messageId) ?? {};\n            if (resolve && reject) {\n                this.responseMap.delete(messageId);\n                if (success) {\n                    resolve(payload);\n                }\n                else {\n                    reject(error);\n                }\n            }\n            else {\n                console.log('Could not find id in responseMap.');\n                console.log(e);\n            }\n        });\n        this.rtc.channels.request.addEventListener('message', async (e) => {\n            let { data } = e;\n            if (e.data instanceof ArrayBuffer) {\n                data = new TextDecoder().decode(e.data);\n            }\n            const { messageId, action, payload } = JSON.parse(data);\n            if (__classPrivateFieldGet$a(this, _RTCEndpoint_processAction, \"f\")) {\n                try {\n                    const res = await __classPrivateFieldGet$a(this, _RTCEndpoint_processAction, \"f\").call(this, action, payload, endpointIdentity);\n                    this.rtc.channels.response.send(JSON.stringify({\n                        messageId,\n                        payload: res,\n                        success: true\n                    }));\n                }\n                catch (error) {\n                    // Check if RTCDataChannel is open before sending, error gets swallowed here in the case where\n                    // client dispatched then closed or disconnected before the dispatch resolves.\n                    if (this.rtc.channels.response.readyState === 'open') {\n                        this.rtc.channels.response.send(JSON.stringify({\n                            messageId,\n                            error: (0, errors_1$1.errorToPOJO)(error),\n                            success: false\n                        }));\n                    }\n                }\n                // Check if RTCDataChannel is open for same reason as catch block above.\n            }\n            else if (this.rtc.channels.response.readyState === 'open') {\n                this.rtc.channels.response.send(JSON.stringify({\n                    messageId,\n                    success: false,\n                    error: 'Connection not ready.'\n                }));\n            }\n        });\n        this.rtc.rtcClient.addEventListener('connectionstatechange', this.connectionStateChangeHandler);\n        // Disconnect if data channels close unexpectedly, e.g. can happen due to message size > ~255kB (RTCPeerConnection.sctp.maxMessageSizeLimit: 262144)\n        Object.values(this.rtc.channels).forEach((datachannel) => {\n            datachannel.onclose = (e) => {\n                [...this.responseMap.values()].forEach((promise) => promise.reject(new Error('RTCDataChannel closed unexpectedly, this is most commonly caused by message size. Note: RTC Channels have a message size limit of ~255kB.')));\n                this.close();\n                if (__classPrivateFieldGet$a(this, _RTCEndpoint_disconnectListener, \"f\")) {\n                    __classPrivateFieldGet$a(this, _RTCEndpoint_disconnectListener, \"f\").call(this);\n                }\n            };\n        });\n    }\n    onDisconnect(listener) {\n        if (!__classPrivateFieldGet$a(this, _RTCEndpoint_disconnectListener, \"f\")) {\n            __classPrivateFieldSet$8(this, _RTCEndpoint_disconnectListener, listener, \"f\");\n        }\n        else {\n            throw new Error('RTCEndpoint disconnectListener cannot be set twice.');\n        }\n    }\n    receive(listener) {\n        if (__classPrivateFieldGet$a(this, _RTCEndpoint_processAction, \"f\")) {\n            throw new Error('You have already set a listener for this RTC Endpoint.');\n        }\n        __classPrivateFieldSet$8(this, _RTCEndpoint_processAction, listener, \"f\");\n    }\n    get connected() {\n        return this.rtc.rtcClient.connectionState === 'connected';\n    }\n}\nendpoint.RTCEndpoint = RTCEndpoint;\n_RTCEndpoint_processAction = new WeakMap(), _RTCEndpoint_disconnectListener = new WeakMap();\n\nvar strategy$1 = {};\n\nvar __classPrivateFieldGet$9 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar __classPrivateFieldSet$7 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar _EndpointStrategy_processAction, _EndpointStrategy_endpointMap, _EndpointStrategy_connected;\nObject.defineProperty(strategy$1, \"__esModule\", { value: true });\nstrategy$1.EndpointStrategy = void 0;\nclass EndpointStrategy {\n    // Need to pass in validate endpoint separately from constructor because ts interfaces don't do well with static methods\n    constructor(EndpointType, validateEndpoint, StrategyName) {\n        this.EndpointType = EndpointType;\n        this.StrategyName = StrategyName;\n        _EndpointStrategy_processAction.set(this, null);\n        _EndpointStrategy_endpointMap.set(this, new Map());\n        _EndpointStrategy_connected.set(this, true);\n        this.send = async (endpointId, action, payload) => {\n            return this.getEndpointById(endpointId).send(action, payload);\n        };\n        this.close = async () => {\n            if (__classPrivateFieldGet$9(this, _EndpointStrategy_connected, \"f\")) {\n                __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, \"f\").forEach((endpoint) => endpoint.close());\n                __classPrivateFieldSet$7(this, _EndpointStrategy_endpointMap, new Map(), \"f\");\n            }\n            __classPrivateFieldSet$7(this, _EndpointStrategy_connected, false, \"f\");\n        };\n        this.isValidEndpointPayload = validateEndpoint;\n    }\n    onEndpointDisconnect(endpointId, listener) {\n        this.getEndpointById(endpointId).onDisconnect(listener);\n    }\n    receive(listener) {\n        if (__classPrivateFieldGet$9(this, _EndpointStrategy_processAction, \"f\")) {\n            throw new Error(`You have already set a listener for this ${this.StrategyName} Strategy`);\n        }\n        __classPrivateFieldSet$7(this, _EndpointStrategy_processAction, listener, \"f\");\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, \"f\").forEach((endpoint) => endpoint.receive(__classPrivateFieldGet$9(this, _EndpointStrategy_processAction, \"f\")));\n    }\n    getEndpointById(endpointId) {\n        const endpoint = __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, \"f\").get(endpointId);\n        if (!endpoint) {\n            throw new Error(`Client with endpoint id ${endpointId} is not connected`);\n        }\n        return endpoint;\n    }\n    get connected() {\n        return __classPrivateFieldGet$9(this, _EndpointStrategy_connected, \"f\");\n    }\n    isEndpointConnected(endpointId) {\n        return __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, \"f\").has(endpointId);\n    }\n    addEndpoint(endpointId, payload) {\n        if (!__classPrivateFieldGet$9(this, _EndpointStrategy_connected, \"f\")) {\n            console.warn(`Adding endpoint to disconnected ${this.StrategyName} Strategy`);\n            return;\n        }\n        const clientStrat = new this.EndpointType(payload);\n        if (__classPrivateFieldGet$9(this, _EndpointStrategy_processAction, \"f\")) {\n            clientStrat.receive(__classPrivateFieldGet$9(this, _EndpointStrategy_processAction, \"f\"));\n        }\n        __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, \"f\").set(endpointId, clientStrat);\n    }\n    async closeEndpoint(endpointId) {\n        __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, \"f\").delete(endpointId);\n    }\n}\nstrategy$1.EndpointStrategy = EndpointStrategy;\n_EndpointStrategy_processAction = new WeakMap(), _EndpointStrategy_endpointMap = new WeakMap(), _EndpointStrategy_connected = new WeakMap();\n\nObject.defineProperty(strategy$2, \"__esModule\", { value: true });\nstrategy$2.RTCInfo = strategy$2.RTCStrategy = void 0;\n/* eslint-disable @typescript-eslint/no-unused-vars */\n/* eslint-disable class-methods-use-this */\nconst endpoint_1 = endpoint;\nconst strategy_1$1 = strategy$1;\n/*\nThis is used to abstract out rtc messaging from the channels implementation using RTCEndpoints.\n*/\nclass RTCStrategy extends strategy_1$1.EndpointStrategy {\n    constructor() {\n        super(endpoint_1.RTCEndpoint, endpoint_1.RTCEndpoint.isValidEndpointPayload, 'RTC');\n    }\n}\nstrategy$2.RTCStrategy = RTCStrategy;\nstrategy$2.RTCInfo = { version: 2, minimumVersion: 0, type: 'rtc' };\n\nvar iceManager = {};\n\nObject.defineProperty(iceManager, \"__esModule\", { value: true });\niceManager.RTCICEManager = void 0;\nconst base_1$h = base;\n/*\nSingleton that facilitates Offer and Answer exchange required for establishing RTC connections.\n*/\nclass RTCICEManager extends base_1$h.EmitterBase {\n    constructor(wire) {\n        super(wire, 'channel');\n        this.ensureChannelOpened = (channel) => {\n            return new Promise((resolve, reject) => {\n                if (channel.readyState === 'open') {\n                    resolve();\n                }\n                else if (channel.readyState === 'connecting') {\n                    const listener = () => {\n                        channel.removeEventListener('open', listener);\n                        resolve();\n                    };\n                    channel.addEventListener('open', listener);\n                }\n                else {\n                    reject(new Error('This Channel has already closed'));\n                }\n            });\n        };\n    }\n    static createDataChannelPromise(label, rtcClient) {\n        let resolver;\n        const promise = new Promise((resolve) => {\n            resolver = resolve;\n        });\n        const listener = (e) => {\n            const openListener = () => {\n                e.channel.removeEventListener('open', openListener);\n                resolver(e.channel);\n            };\n            if (e.channel.label === label) {\n                e.channel.addEventListener('open', openListener);\n                rtcClient.removeEventListener('datachannel', listener);\n            }\n        };\n        rtcClient.addEventListener('datachannel', listener);\n        return promise;\n    }\n    async listenForProviderIce(rtcConnectionId, listener) {\n        await this.on(this.createProviderEventName(rtcConnectionId), listener, { timestamp: Date.now() });\n    }\n    async raiseProviderIce(rtcConnectionId, payload) {\n        await this.wire.environment.raiseEvent(this.createRouteString(this.createProviderEventName(rtcConnectionId)), payload);\n    }\n    async listenForClientIce(rtcConnectionId, listener) {\n        await this.on(this.createClientEventName(rtcConnectionId), listener, { timestamp: Date.now() });\n    }\n    async raiseClientIce(rtcConnectionId, payload) {\n        await this.wire.environment.raiseEvent(this.createRouteString(this.createClientEventName(rtcConnectionId)), payload);\n    }\n    cleanupIceListeners(rtcConnectionId) {\n        this.removeAllListeners(this.createClientEventName(rtcConnectionId));\n        this.removeAllListeners(this.createProviderEventName(rtcConnectionId));\n    }\n    createClientEventName(rtcConnectionId) {\n        return `ice-client-${rtcConnectionId}`;\n    }\n    createProviderEventName(rtcConnectionId) {\n        return `ice-provider-${rtcConnectionId}`;\n    }\n    createRouteString(name) {\n        return `channel/${name}`;\n    }\n    createRtcPeer() {\n        return this.wire.environment.getRtcPeer();\n    }\n    async startClientOffer() {\n        // TODO replace with real guid.\n        const rtcConnectionId = Math.random().toString();\n        const rtcClient = this.createRtcPeer();\n        rtcClient.addEventListener('icecandidate', async (e) => {\n            if (e.candidate) {\n                await this.raiseClientIce(rtcConnectionId, { candidate: e.candidate?.toJSON() });\n            }\n        });\n        await this.listenForProviderIce(rtcConnectionId, async (payload) => {\n            await rtcClient.addIceCandidate(payload.candidate);\n        });\n        const channels = {\n            request: rtcClient.createDataChannel('request'),\n            response: rtcClient.createDataChannel('response')\n        };\n        const offer = await rtcClient.createOffer();\n        await rtcClient.setLocalDescription(offer);\n        const channelsOpened = Promise.all([channels.request, channels.response].map(this.ensureChannelOpened)).then(() => undefined);\n        return { rtcClient, channels, offer, rtcConnectionId, channelsOpened };\n    }\n    async finishClientOffer(rtcClient, answer, providerReady) {\n        await rtcClient.setRemoteDescription(answer);\n        await providerReady;\n        return true;\n    }\n    async createProviderAnswer(rtcConnectionId, offer) {\n        const rtcClient = this.createRtcPeer();\n        const requestChannelPromise = RTCICEManager.createDataChannelPromise('request', rtcClient);\n        const responseChannelPromise = RTCICEManager.createDataChannelPromise('response', rtcClient);\n        rtcClient.addEventListener('icecandidate', async (e) => {\n            if (e.candidate) {\n                await this.raiseProviderIce(rtcConnectionId, { candidate: e.candidate?.toJSON() });\n            }\n        });\n        await this.listenForClientIce(rtcConnectionId, async (payload) => {\n            await rtcClient.addIceCandidate(payload.candidate);\n        });\n        await rtcClient.setRemoteDescription(offer);\n        const answer = await rtcClient.createAnswer();\n        await rtcClient.setLocalDescription(answer);\n        const channels = Promise.all([requestChannelPromise, responseChannelPromise]).then(([request, response]) => {\n            // Clean up ice events.\n            this.cleanupIceListeners(rtcConnectionId);\n            return { request, response };\n        });\n        return {\n            rtcClient,\n            answer,\n            channels\n        };\n    }\n}\niceManager.RTCICEManager = RTCICEManager;\n\nvar provider = {};\n\nvar runtimeVersioning = {};\n\nObject.defineProperty(runtimeVersioning, \"__esModule\", { value: true });\nruntimeVersioning.runtimeUuidMeetsMinimumRuntimeVersion = runtimeVersioning.parseRuntimeUuid = runtimeVersioning.meetsMinimumRuntimeVersion = void 0;\nfunction vNum(x) {\n    return [...x.split('.').reverse().entries()].reduce((p, [i, v]) => p + +v * 10000 ** i, 0);\n}\n/*\n  Compares runtime versions to see if the current runtime meets your desired minimum.\n*/\nfunction meetsMinimumRuntimeVersion(currentVersion, minVersion) {\n    const currentVersionParsed = vNum(currentVersion);\n    const minVersionParsed = vNum(minVersion);\n    return currentVersionParsed >= minVersionParsed;\n}\nruntimeVersioning.meetsMinimumRuntimeVersion = meetsMinimumRuntimeVersion;\n// Strips the port info from the runtimeUuid, leaving just the runtime version.\nfunction parseRuntimeUuid(runtimeUuid) {\n    return runtimeUuid.split('/')[0];\n}\nruntimeVersioning.parseRuntimeUuid = parseRuntimeUuid;\nfunction runtimeUuidMeetsMinimumRuntimeVersion(runtimeUuid, minVersion) {\n    const runtimeVersion = parseRuntimeUuid(runtimeUuid);\n    return meetsMinimumRuntimeVersion(runtimeVersion, minVersion);\n}\nruntimeVersioning.runtimeUuidMeetsMinimumRuntimeVersion = runtimeUuidMeetsMinimumRuntimeVersion;\n\nvar __classPrivateFieldGet$8 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar __classPrivateFieldSet$6 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar _ChannelProvider_connections, _ChannelProvider_protectedObj, _ChannelProvider_strategy, _ChannelProvider_removeEndpoint, _ChannelProvider_close;\nObject.defineProperty(provider, \"__esModule\", { value: true });\nprovider.ChannelProvider = void 0;\nconst channel_1 = channel;\nconst runtimeVersioning_1 = runtimeVersioning;\n/**\n * Instance created to enable use of a channel as a provider. Allows for communication with the {@link ChannelClient ChannelClients} by invoking an action on\n * a single client via {@link ChannelProvider#dispatch dispatch} or all clients via {@link ChannelProvider#publish publish}\n * and to listen for communication from clients by registering an action via {@link ChannelProvider#register register}.\n *\n * ### Synchronous Methods:\n *  * {@link ChannelProvider#onConnection onConnection(listener)}\n *  * {@link ChannelProvider#onDisconnection onDisconnection(listener)}\n *  * {@link ChannelProvider#publish publish(action, payload)}\n *  * {@link ChannelProvider#register register(action, listener)}\n *  * {@link ChannelProvider#remove remove(action)}\n *\n * ### Asynchronous Methods:\n *  * {@link ChannelProvider#destroy destroy()}\n *  * {@link ChannelProvider#dispatch dispatch(to, action, payload)}\n *  * {@link ChannelProvider#getAllClientInfo getAllClientInfo()}\n *\n * ### Middleware:\n * Middleware functions receive the following arguments: (action, payload, senderId).\n * The return value of the middleware function will be passed on as the payload from beforeAction, to the action listener, to afterAction\n * unless it is undefined, in which case the most recently defined payload is used.  Middleware can be used for side effects.\n *  * {@link ChannelProvider#setDefaultAction setDefaultAction(middleware)}\n *  * {@link ChannelProvider#onError onError(middleware)}\n *  * {@link ChannelProvider#beforeAction beforeAction(middleware)}\n *  * {@link ChannelProvider#afterAction afterAction(middleware)}\n */\nclass ChannelProvider extends channel_1.ChannelBase {\n    /**\n     * a read-only array containing all the identities of connecting clients.\n     */\n    get connections() {\n        return [...__classPrivateFieldGet$8(this, _ChannelProvider_connections, \"f\")];\n    }\n    static handleClientDisconnection(channel, payload) {\n        const removeById = channel.connections.find((identity) => identity.endpointId === payload.endpointId);\n        if (removeById) {\n            __classPrivateFieldGet$8(channel, _ChannelProvider_removeEndpoint, \"f\").call(channel, removeById);\n        }\n        else {\n            const multipleRemoves = channel.connections.filter((identity) => {\n                return identity.uuid === payload.uuid && identity.name === payload.name;\n            });\n            multipleRemoves.forEach(__classPrivateFieldGet$8(channel, _ChannelProvider_removeEndpoint, \"f\"));\n        }\n        channel.disconnectListener(payload);\n    }\n    static setProviderRemoval(provider, remove) {\n        ChannelProvider.removalMap.set(provider, remove);\n    }\n    /**\n     * @internal\n     */\n    constructor(providerIdentity, close, strategy) {\n        super();\n        _ChannelProvider_connections.set(this, void 0);\n        _ChannelProvider_protectedObj.set(this, void 0);\n        _ChannelProvider_strategy.set(this, void 0);\n        _ChannelProvider_removeEndpoint.set(this, (identity) => {\n            const remainingConnections = this.connections.filter((clientIdentity) => clientIdentity.endpointId !== identity.endpointId);\n            __classPrivateFieldGet$8(this, _ChannelProvider_strategy, \"f\").closeEndpoint(identity.endpointId);\n            __classPrivateFieldSet$6(this, _ChannelProvider_connections, remainingConnections, \"f\");\n        });\n        // Must be bound.\n        this.processAction = async (action, payload, senderIdentity) => {\n            if (ChannelProvider.clientIsMultiRuntime(senderIdentity) &&\n                !(0, runtimeVersioning_1.runtimeUuidMeetsMinimumRuntimeVersion)(senderIdentity.runtimeUuid, '18.87.56.0')) {\n                this.handleMultiRuntimeLegacyClient(senderIdentity);\n            }\n            else {\n                this.checkForClientConnection(senderIdentity);\n            }\n            return super.processAction(action, payload, senderIdentity);\n        };\n        _ChannelProvider_close.set(this, () => {\n            __classPrivateFieldGet$8(this, _ChannelProvider_strategy, \"f\").close();\n            const remove = ChannelProvider.removalMap.get(this);\n            if (remove) {\n                remove();\n            }\n        });\n        __classPrivateFieldSet$6(this, _ChannelProvider_protectedObj, new channel_1.ProtectedItems(providerIdentity, close), \"f\");\n        this.connectListener = () => undefined;\n        this.disconnectListener = () => undefined;\n        __classPrivateFieldSet$6(this, _ChannelProvider_connections, [], \"f\");\n        __classPrivateFieldSet$6(this, _ChannelProvider_strategy, strategy, \"f\");\n        strategy.receive(this.processAction);\n    }\n    /**\n     * Dispatch an action to a specified client. Returns a promise for the result of executing that action on the client side.\n     *\n     * @param to - Identity of the target client.\n     * @param action - Name of the action to be invoked by the client.\n     * @param payload - Payload to be sent along with the action.\n     *\n     * @remarks\n     *\n     * Because multiple clients can share the same `name` and `uuid`, when dispatching from a provider to a client,\n     * the `identity` you provide must include the client's unique `endpointId` property. This `endpointId` is\n     * passed to the provider in both the `Provider.onConnection` callback and in any registered action callbacks.\n     *\n     * @example\n     *\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     await provider.register('provider-action', async (payload, identity) => {\n     *         console.log(payload, identity);\n     *         return await provider.dispatch(identity, 'client-action', 'Hello, World!');\n     *     });\n     * })();\n     * ```\n     */\n    dispatch(to, action, payload) {\n        const endpointId = to.endpointId ?? this.getEndpointIdForOpenFinId(to, action);\n        if (endpointId && __classPrivateFieldGet$8(this, _ChannelProvider_strategy, \"f\").isEndpointConnected(endpointId)) {\n            return __classPrivateFieldGet$8(this, _ChannelProvider_strategy, \"f\").send(endpointId, action, payload);\n        }\n        return Promise.reject(new Error(`Client connection with identity uuid: ${to.uuid} / name: ${to.name} / endpointId: ${endpointId} no longer connected.`));\n    }\n    async processConnection(senderId, payload) {\n        __classPrivateFieldGet$8(this, _ChannelProvider_connections, \"f\").push(senderId);\n        return this.connectListener(senderId, payload);\n    }\n    /**\n     * Publish an action and payload to every connected client.\n     * Synchronously returns an array of promises for each action (see dispatch).\n     *\n     * @param action\n     * @param payload\n     *\n     * @example\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     await provider.register('provider-action', async (payload, identity) => {\n     *         console.log(payload, identity);\n     *         return await Promise.all(provider.publish('client-action', { message: 'Broadcast from provider'}));\n     *     });\n     * })();\n     * ```\n     */\n    publish(action, payload) {\n        return this.connections.map((to) => __classPrivateFieldGet$8(this, _ChannelProvider_strategy, \"f\").send(to.endpointId, action, payload));\n    }\n    /**\n     * Register a listener that is called on every new client connection.\n     *\n     * @remarks It is passed the identity of the connecting client and a payload if it was provided to Channel.connect.\n     * If you wish to reject the connection, throw an error. Be sure to synchronously provide an onConnection upon receipt of\n     * the channelProvider to ensure all potential client connections are caught by the listener.\n     *\n     * Because multiple clients can exist at the same `name` and `uuid`, in order to distinguish between individual clients,\n     * the `identity` argument in a provider's `onConnection` callback contains an `endpointId` property. When dispatching from a\n     * provider to a client, the `endpointId` property must be provided in order to send an action to a specific client.\n     *\n     * @example\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     provider.onConnection(identity => {\n     *         console.log('Client connected', identity);\n     *     });\n     * })();\n     * ```\n     *\n     * Reject connection:\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     provider.onConnection(identity => {\n     *         throw new Error('Connection Rejected');\n     *     });\n     * })();\n     * ```\n     * @param listener\n     */\n    onConnection(listener) {\n        this.connectListener = listener;\n    }\n    /**\n     * Register a listener that is called on client disconnection. It is passed the disconnection event of the disconnecting\n     * client.\n     *\n     * @param listener\n     *\n     * @example\n     *\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     await provider.onDisconnection(evt => {\n     *         console.log('Client disconnected', `uuid: ${evt.uuid}, name: ${evt.name}`);\n     *     });\n     * })();\n     * ```\n     */\n    onDisconnection(listener) {\n        this.disconnectListener = listener;\n    }\n    /**\n     * Destroy the channel, raises `disconnected` events on all connected channel clients.\n     *\n     * @example\n     *\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     await provider.destroy();\n     * })();\n     * ```\n     */\n    async destroy() {\n        const protectedObj = __classPrivateFieldGet$8(this, _ChannelProvider_protectedObj, \"f\");\n        protectedObj.providerIdentity;\n        __classPrivateFieldSet$6(this, _ChannelProvider_connections, [], \"f\");\n        await protectedObj.close();\n        __classPrivateFieldGet$8(this, _ChannelProvider_close, \"f\").call(this);\n    }\n    /**\n     * Returns an array with info on every Client connected to the Provider\n     *\n     * @example\n     *\n     * ```js\n     * const provider = await fin.InterApplicationBus.Channel.create('openfin');\n     * const client = await fin.InterApplicationBus.Channel.connect('openfin');\n     * const clientInfo = await provider.getAllClientInfo();\n     *\n     * console.log(clientInfo);\n     *\n     * // [\n     * //    {\n     * //        \"uuid\": \"openfin\",\n     * //        \"name\": \"openfin-view\",\n     * //        \"endpointId\": \"6d4c7ca8-4a74-4634-87f8-760558229613\",\n     * //        \"entityType\": \"view\",\n     * //        \"url\": \"https://openfin.co\"\n     * //    },\n     * //    {\n     * //        \"uuid\": \"openfin2\",\n     * //        \"name\": \"openfin-view2\",\n     * //        \"endpointId\": \"4z5d8ab9-2b81-3691-91ex-142179382511\",\n     * //        \"entityType\": \"view\",\n     * //        \"url\": \"https://example.com\"\n     * //    }\n     * //]\n     * ```\n     */\n    async getAllClientInfo() {\n        return this.connections.map((clientInfo) => {\n            const { uuid, name, endpointId, entityType, connectionUrl } = clientInfo;\n            return { uuid, name, endpointId, entityType, connectionUrl };\n        });\n    }\n    checkForClientConnection(clientIdentity) {\n        if (!this.isClientConnected(clientIdentity)) {\n            throw new Error(`This action was sent from a client that is not connected to the provider.\n                    Client Identity: {uuid: ${clientIdentity.uuid}, name: ${clientIdentity.name}, endpointId: ${clientIdentity.endpointId}}`);\n        }\n    }\n    isClientConnected(clientIdentity) {\n        if (ChannelProvider.clientIdentityIncludesEndpointId(clientIdentity)) {\n            return this.connections.some((identity) => {\n                return (\n                // Might be redundant to check for uuid and name here after we get an endpointId match, but just in case\n                identity.endpointId === clientIdentity.endpointId &&\n                    identity.uuid === clientIdentity.uuid &&\n                    identity.name === clientIdentity.name);\n            });\n        }\n        return this.isLegacyClientConnected(clientIdentity);\n    }\n    isLegacyClientConnected(clientIdentity) {\n        return this.connections.some((identity) => {\n            return identity.uuid === clientIdentity.uuid && identity.name === clientIdentity.name;\n        });\n    }\n    handleMultiRuntimeLegacyClient(senderIdentity) {\n        if (!this.isLegacyClientConnected(senderIdentity)) {\n            throw new Error(`This action was sent from a client that is not connected to the provider. Client Identity:\n                    {uuid: ${senderIdentity.uuid}, name: ${senderIdentity.name}, endpointId: ${senderIdentity.endpointId}}`);\n        }\n    }\n    getEndpointIdForOpenFinId(clientIdentity, action) {\n        const matchingConnections = this.connections.filter((c) => c.name === clientIdentity.name && c.uuid === clientIdentity.uuid);\n        if (matchingConnections.length >= 2) {\n            const protectedObj = __classPrivateFieldGet$8(this, _ChannelProvider_protectedObj, \"f\");\n            const { uuid, name } = clientIdentity;\n            const providerUuid = protectedObj?.providerIdentity.uuid;\n            const providerName = protectedObj?.providerIdentity.name;\n            // eslint-disable-next-line no-console\n            console.warn(`WARNING: Dispatch call may have unintended results. The \"to\" argument of your dispatch call is missing the\n                \"endpointId\" parameter. The identity you are dispatching to ({uuid: ${uuid}, name: ${name}})\n                has multiple channelClients for this channel. Your dispatched action: (${action}) from the provider:\n                ({uuid: ${providerUuid}, name: ${providerName}}) will only be processed by the most recently-created client.`);\n        }\n        // Pop to return the most recently created endpointId.\n        return matchingConnections.pop()?.endpointId;\n    }\n    // eslint-disable-next-line class-methods-use-this\n    static clientIdentityIncludesEndpointId(subscriptionIdentity) {\n        return subscriptionIdentity.endpointId !== undefined;\n    }\n    // eslint-disable-next-line class-methods-use-this\n    static clientIsMultiRuntime(subscriptionIdentity) {\n        return subscriptionIdentity.runtimeUuid !== undefined;\n    }\n    static async wireClose(wire, channelName) {\n        await wire.sendAction('destroy-channel', { channelName });\n    }\n}\nprovider.ChannelProvider = ChannelProvider;\n_ChannelProvider_connections = new WeakMap(), _ChannelProvider_protectedObj = new WeakMap(), _ChannelProvider_strategy = new WeakMap(), _ChannelProvider_removeEndpoint = new WeakMap(), _ChannelProvider_close = new WeakMap();\n// The following line should be changed following a typescript update.\n// static #removalMap = new WeakMap<ChannelProvider, Function>();\nChannelProvider.removalMap = new WeakMap();\n\nvar messageReceiver = {};\n\nObject.defineProperty(messageReceiver, \"__esModule\", { value: true });\nmessageReceiver.MessageReceiver = void 0;\nconst client_1$1 = client;\nconst base_1$g = base;\n/*\nThis is a singleton (per fin object) tasked with routing messages coming off the ipc to the correct endpoint.\nIt needs to be a singleton because there can only be one per wire. It tracks both clients and providers' processAction passed in via the strategy.\nIf functionality is not about receiving messages, it does not belong here.\n*/\nclass MessageReceiver extends base_1$g.Base {\n    constructor(wire) {\n        super(wire);\n        this.onmessage = (msg) => {\n            if (msg.action === 'process-channel-message') {\n                this.processChannelMessage(msg);\n                return true;\n            }\n            return false;\n        };\n        this.endpointMap = new Map();\n        this.latestEndpointIdByChannelId = new Map();\n        wire.registerMessageHandler(this.onmessage.bind(this));\n    }\n    async processChannelMessage(msg) {\n        const { senderIdentity, providerIdentity, action, ackToSender, payload, intendedTargetIdentity } = msg.payload;\n        const key = intendedTargetIdentity.channelId ?? // The recipient is a provider\n            intendedTargetIdentity.endpointId ?? // The recipient is a client\n            this.latestEndpointIdByChannelId.get(providerIdentity.channelId); // No endpointId was passed, make best attempt\n        const handler = this.endpointMap.get(key);\n        if (!handler) {\n            ackToSender.payload.success = false;\n            ackToSender.payload.reason = `Client connection with identity uuid: ${this.wire.me.uuid} / name: ${this.wire.me.name} / endpointId: ${key} no longer connected.`;\n            return this.wire.sendRaw(ackToSender);\n        }\n        try {\n            const res = await handler(action, payload, senderIdentity);\n            ackToSender.payload.payload = ackToSender.payload.payload || {};\n            ackToSender.payload.payload.result = res;\n            return this.wire.sendRaw(ackToSender);\n        }\n        catch (e) {\n            ackToSender.payload.success = false;\n            ackToSender.payload.reason = e.message;\n            return this.wire.sendRaw(ackToSender);\n        }\n    }\n    addEndpoint(handler, channelId, endpointId) {\n        this.endpointMap.set(endpointId, handler);\n        // Providers have the same endpointId and channelId.\n        // This is only used when clients are receiving messages from providers, so we shouldn't save provider endpointId here.\n        if (channelId !== endpointId) {\n            this.latestEndpointIdByChannelId.set(channelId, endpointId);\n        }\n    }\n    removeEndpoint(channelId, endpointId) {\n        this.endpointMap.delete(endpointId);\n        if (this.latestEndpointIdByChannelId.get(channelId) === endpointId) {\n            this.latestEndpointIdByChannelId.delete(channelId);\n        }\n    }\n    checkForPreviousClientConnection(channelId) {\n        const endpointIdFromPreviousConnection = this.latestEndpointIdByChannelId.get(channelId);\n        if (endpointIdFromPreviousConnection) {\n            // Not convinced by this way of doing things, but pushing up for now.\n            client_1$1.ChannelClient.closeChannelByEndpointId(endpointIdFromPreviousConnection);\n            // eslint-disable-next-line no-console\n            console.warn('You have created a second connection to an older provider. First connection has been removed from the clientMap');\n            // eslint-disable-next-line no-console\n            console.warn('If the provider calls publish(), you may receive multiple messages.');\n        }\n    }\n}\nmessageReceiver.MessageReceiver = MessageReceiver;\n\nvar protocolManager = {};\n\nObject.defineProperty(protocolManager, \"__esModule\", { value: true });\nprotocolManager.ProtocolManager = void 0;\n/*\nThis should be agnostic of any actual openfin code to be unit testable.\nDependencies on the actual srategies should be handled in ConnectionManager\n*/\nclass ProtocolManager {\n    // eslint-disable-next-line no-useless-constructor\n    constructor(ProtocolsInPreferenceOrder) {\n        this.ProtocolsInPreferenceOrder = ProtocolsInPreferenceOrder;\n        this.DefaultClientProtocols = ['classic'];\n        this.DefaultProviderProtocols = ['classic'];\n        this.getClientProtocols = (protocols) => {\n            const supported = protocols\n                ? this.ProtocolsInPreferenceOrder.filter((x) => protocols.includes(x))\n                : this.DefaultClientProtocols;\n            if (!supported.length) {\n                throw new Error(`No valid protocols were passed in. Accepted values are: ${this.ProtocolsInPreferenceOrder.join(', ')}.`);\n            }\n            return supported;\n        };\n        this.getProviderProtocols = (protocols) => {\n            const supported = protocols\n                ? this.ProtocolsInPreferenceOrder.filter((x) => protocols.includes(x))\n                : this.DefaultProviderProtocols;\n            if (!supported.length) {\n                throw new Error(`No valid protocols were passed in. Accepted values are: ${this.ProtocolsInPreferenceOrder.join(', ')}.`);\n            }\n            return supported;\n        };\n        this.getCompatibleProtocols = (providerProtocols, clientOffer) => {\n            const supported = clientOffer.supportedProtocols.filter((clientProtocol) => providerProtocols.some((providerProtocol) => providerProtocol.type === clientProtocol.type &&\n                clientProtocol.version >= providerProtocol.minimumVersion &&\n                providerProtocol.version >= (clientProtocol.minimumVersion ?? 0)));\n            return supported.slice(0, clientOffer.maxProtocols);\n        };\n    }\n}\nprotocolManager.ProtocolManager = ProtocolManager;\n\nvar strategy = {};\n\nObject.defineProperty(strategy, \"__esModule\", { value: true });\nclass CombinedStrategy {\n    // Making this a static method because the constructor can't be typed.\n    // Otherwise it will error when calling addEndpoint but I'd rather the whole instance be typed as never.\n    static combine(a, b) {\n        return new CombinedStrategy(a, b);\n    }\n    // eslint-disable-next-line no-useless-constructor\n    constructor(primary, secondary) {\n        this.primary = primary;\n        this.secondary = secondary;\n    }\n    onEndpointDisconnect(endpointId, listener) {\n        this.primary.onEndpointDisconnect(endpointId, () => {\n            if (!this.secondary.isEndpointConnected(endpointId)) {\n                listener();\n            }\n        });\n        this.secondary.onEndpointDisconnect(endpointId, () => {\n            if (!this.primary.isEndpointConnected(endpointId)) {\n                listener();\n            }\n        });\n    }\n    isValidEndpointPayload(payload) {\n        return this.primary.isValidEndpointPayload(payload) || this.secondary.isValidEndpointPayload(payload);\n    }\n    async closeEndpoint(endpointId) {\n        await this.primary.closeEndpoint(endpointId);\n        await this.secondary.closeEndpoint(endpointId);\n    }\n    isEndpointConnected(endpoint) {\n        return this.primary.isEndpointConnected(endpoint) || this.secondary.isEndpointConnected(endpoint);\n    }\n    async addEndpoint(endpoint, payload) {\n        if (this.primary.isValidEndpointPayload(payload)) {\n            await this.primary.addEndpoint(endpoint, payload);\n        }\n        if (this.secondary.isValidEndpointPayload(payload)) {\n            await this.secondary.addEndpoint(endpoint, payload);\n        }\n    }\n    receive(listener) {\n        this.primary.receive(listener);\n        this.secondary.receive(listener);\n    }\n    send(endpointId, action, payload) {\n        if (this.primary.isEndpointConnected(endpointId)) {\n            return this.primary.send(endpointId, action, payload);\n        }\n        return this.secondary.send(endpointId, action, payload);\n    }\n    async close() {\n        await Promise.all([this.primary.close(), this.secondary.close()]);\n    }\n}\nstrategy.default = CombinedStrategy;\n\nvar __classPrivateFieldSet$5 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar __classPrivateFieldGet$7 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar __importDefault$1 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nvar _ConnectionManager_messageReceiver, _ConnectionManager_rtcConnectionManager;\nObject.defineProperty(connectionManager, \"__esModule\", { value: true });\nconnectionManager.ConnectionManager = void 0;\nconst exhaustive_1 = exhaustive;\nconst base_1$f = base;\nconst strategy_1 = strategy$3;\nconst strategy_2 = strategy$2;\nconst ice_manager_1 = iceManager;\nconst provider_1$1 = provider;\nconst message_receiver_1 = messageReceiver;\nconst protocol_manager_1 = protocolManager;\nconst strategy_3 = __importDefault$1(strategy);\nclass ConnectionManager extends base_1$f.Base {\n    static getProtocolOptionsFromStrings(protocols) {\n        return protocols.map((protocol) => {\n            switch (protocol) {\n                case 'rtc':\n                    return strategy_2.RTCInfo;\n                case 'classic':\n                    return strategy_1.ClassicInfo;\n                default:\n                    return (0, exhaustive_1.exhaustiveCheck)(protocol, ['rtc', 'classic']);\n            }\n        });\n    }\n    constructor(wire) {\n        super(wire);\n        _ConnectionManager_messageReceiver.set(this, void 0);\n        _ConnectionManager_rtcConnectionManager.set(this, void 0);\n        this.removeChannelFromProviderMap = (channelId) => {\n            this.providerMap.delete(channelId);\n        };\n        this.onmessage = (msg) => {\n            if (msg.action === 'process-channel-connection') {\n                this.processChannelConnection(msg);\n                return true;\n            }\n            return false;\n        };\n        this.providerMap = new Map();\n        this.protocolManager = new protocol_manager_1.ProtocolManager(this.wire.environment.type === 'node' ? ['classic'] : ['rtc', 'classic']);\n        __classPrivateFieldSet$5(this, _ConnectionManager_messageReceiver, new message_receiver_1.MessageReceiver(wire), \"f\");\n        __classPrivateFieldSet$5(this, _ConnectionManager_rtcConnectionManager, new ice_manager_1.RTCICEManager(wire), \"f\");\n        wire.registerMessageHandler(this.onmessage.bind(this));\n    }\n    createProvider(options, providerIdentity) {\n        const opts = Object.assign(this.wire.environment.getDefaultChannelOptions().create, options || {});\n        const protocols = this.protocolManager.getProviderProtocols(opts?.protocols);\n        const createSingleStrategy = (stratType) => {\n            switch (stratType) {\n                case 'rtc':\n                    return new strategy_2.RTCStrategy();\n                case 'classic':\n                    return new strategy_1.ClassicStrategy(this.wire, __classPrivateFieldGet$7(this, _ConnectionManager_messageReceiver, \"f\"), \n                    // Providers do not have an endpointId, use channelId as endpointId in the strategy.\n                    providerIdentity.channelId, providerIdentity);\n                default:\n                    return (0, exhaustive_1.exhaustiveCheck)(stratType, ['rtc', 'classic']);\n            }\n        };\n        const strategies = protocols.map(createSingleStrategy);\n        let strategy;\n        if (strategies.length === 2) {\n            const [a, b] = strategies;\n            strategy = strategy_3.default.combine(a, b);\n        }\n        else if (strategies.length === 1) {\n            [strategy] = strategies;\n        }\n        else {\n            // Should be impossible.\n            throw new Error('failed to combine strategies');\n        }\n        const channel = new provider_1$1.ChannelProvider(providerIdentity, () => provider_1$1.ChannelProvider.wireClose(this.wire, providerIdentity.channelName), strategy);\n        const key = providerIdentity.channelId;\n        this.providerMap.set(key, {\n            provider: channel,\n            strategy,\n            supportedProtocols: ConnectionManager.getProtocolOptionsFromStrings(protocols)\n        });\n        provider_1$1.ChannelProvider.setProviderRemoval(channel, this.removeChannelFromProviderMap.bind(this));\n        return channel;\n    }\n    async createClientOffer(options) {\n        const protocols = this.protocolManager.getClientProtocols(options?.protocols);\n        let rtcPacket;\n        const supportedProtocols = await Promise.all(protocols.map(async (type) => {\n            switch (type) {\n                case 'rtc': {\n                    const { rtcClient, channels, offer, rtcConnectionId, channelsOpened } = await __classPrivateFieldGet$7(this, _ConnectionManager_rtcConnectionManager, \"f\").startClientOffer();\n                    rtcPacket = { rtcClient, channels, channelsOpened };\n                    return {\n                        type: 'rtc',\n                        version: strategy_2.RTCInfo.version,\n                        payload: { offer, rtcConnectionId }\n                    };\n                }\n                case 'classic':\n                    return { type: 'classic', version: strategy_1.ClassicInfo.version };\n                default:\n                    return (0, exhaustive_1.exhaustiveCheck)(type, ['rtc', 'classic']);\n            }\n        }));\n        return {\n            offer: {\n                supportedProtocols,\n                maxProtocols: 2\n            },\n            rtc: rtcPacket\n        };\n    }\n    async createClientStrategy(rtcPacket, routingInfo) {\n        if (!routingInfo.endpointId) {\n            routingInfo.endpointId = this.wire.environment.getNextMessageId();\n            // For New Clients connecting to Old Providers. To prevent multi-dispatching and publishing, we delete previously-connected\n            // clients that are in the same context as the newly-connected client.\n            __classPrivateFieldGet$7(this, _ConnectionManager_messageReceiver, \"f\").checkForPreviousClientConnection(routingInfo.channelId);\n        }\n        const answer = routingInfo.answer ?? {\n            supportedProtocols: [{ type: 'classic', version: 1 }]\n        };\n        const createStrategyFromAnswer = async (protocol) => {\n            if (protocol.type === 'rtc' && rtcPacket) {\n                await __classPrivateFieldGet$7(this, _ConnectionManager_rtcConnectionManager, \"f\").finishClientOffer(rtcPacket.rtcClient, protocol.payload.answer, rtcPacket.channelsOpened);\n                return new strategy_2.RTCStrategy();\n            }\n            if (protocol.type === 'classic') {\n                return new strategy_1.ClassicStrategy(this.wire, __classPrivateFieldGet$7(this, _ConnectionManager_messageReceiver, \"f\"), routingInfo.endpointId, routingInfo);\n            }\n            return null;\n        };\n        const allProtocols = (await Promise.all(answer.supportedProtocols.map(createStrategyFromAnswer))).filter((x) => x !== null);\n        // Clean up logic if provider didn't support rtc.\n        if (rtcPacket && !allProtocols.some((x) => x instanceof strategy_2.RTCStrategy)) {\n            if (rtcPacket) {\n                rtcPacket.rtcClient.close();\n            }\n        }\n        let strategy;\n        if (allProtocols.length >= 2) {\n            strategy = strategy_3.default.combine(allProtocols[0], allProtocols[1]);\n        }\n        else if (allProtocols.length) {\n            [strategy] = allProtocols;\n        }\n        else {\n            // Should be impossible.\n            throw new Error('No compatible protocols');\n        }\n        // as casting rtcPacket because we won't have an rtcStrategy if rtcPacket is undefined;\n        const endpointPayload = { endpointIdentity: routingInfo, rtc: rtcPacket };\n        strategy.addEndpoint(routingInfo.channelId, endpointPayload);\n        return strategy;\n    }\n    async processChannelConnection(msg) {\n        const { clientIdentity, providerIdentity, ackToSender, payload, offer: clientOffer } = msg.payload;\n        if (!clientIdentity.endpointId) {\n            // Should be polyfilled by core but not in cases of node connecting to an old runtime.\n            clientIdentity.endpointId = this.wire.environment.getNextMessageId();\n            clientIdentity.isLocalEndpointId = true;\n        }\n        else {\n            clientIdentity.isLocalEndpointId = false;\n        }\n        const key = providerIdentity.channelId;\n        const bus = this.providerMap.get(key);\n        if (!bus) {\n            ackToSender.payload.success = false;\n            ackToSender.payload.reason = `Channel \"${providerIdentity.channelName}\" has been destroyed.`;\n            return this.wire.sendRaw(ackToSender);\n        }\n        const { provider, strategy, supportedProtocols } = bus;\n        try {\n            if (!(provider instanceof provider_1$1.ChannelProvider)) {\n                throw Error('Cannot connect to a channel client');\n            }\n            const offer = clientOffer ?? {\n                supportedProtocols: [{ type: 'classic', version: 1 }],\n                maxProtocols: 1\n            };\n            const overlappingProtocols = this.protocolManager.getCompatibleProtocols(supportedProtocols, offer);\n            if (!overlappingProtocols.length) {\n                throw new Error('This provider does not support any of the offered protocols.');\n            }\n            const res = await provider.processConnection(clientIdentity, payload);\n            ackToSender.payload.payload = ackToSender.payload.payload || {};\n            // Loop through all supported protocols and accumulate them into the answer\n            // addEndpoint is tricky but we need to wait for channel resolution before adding the endpoint.\n            let clientAnswer = {\n                supportedProtocols: [],\n                endpointPayloadPromise: Promise.resolve({ endpointIdentity: clientIdentity })\n            };\n            clientAnswer = await overlappingProtocols.reduce(async (accumP, protocolToUse) => {\n                const answer = await accumP;\n                if (protocolToUse.type === 'rtc') {\n                    const { answer: rtcAnswer, rtcClient, channels } = await __classPrivateFieldGet$7(this, _ConnectionManager_rtcConnectionManager, \"f\").createProviderAnswer(protocolToUse.payload.rtcConnectionId, protocolToUse.payload.offer);\n                    answer.supportedProtocols.push({\n                        type: 'rtc',\n                        version: strategy_2.RTCInfo.version,\n                        payload: {\n                            answer: rtcAnswer\n                        }\n                    });\n                    answer.endpointPayloadPromise = answer.endpointPayloadPromise.then((endpointPayload) => channels.then((resolvedChannels) => {\n                        return {\n                            ...endpointPayload,\n                            rtc: {\n                                rtcClient,\n                                channels: resolvedChannels\n                            }\n                        };\n                    }));\n                }\n                else {\n                    answer.supportedProtocols.push({ type: 'classic', version: strategy_1.ClassicInfo.version });\n                }\n                return answer;\n            }, Promise.resolve(clientAnswer));\n            // Need to as cast here.\n            clientAnswer.endpointPayloadPromise.then((endpointPayload) => strategy.addEndpoint(clientIdentity.endpointId, endpointPayload));\n            ackToSender.payload.payload.result = res;\n            ackToSender.payload.payload.answer = clientAnswer;\n            return this.wire.sendRaw(ackToSender);\n        }\n        catch (e) {\n            ackToSender.payload.success = false;\n            ackToSender.payload.reason = e.message;\n            return this.wire.sendRaw(ackToSender);\n        }\n    }\n}\nconnectionManager.ConnectionManager = ConnectionManager;\n_ConnectionManager_messageReceiver = new WeakMap(), _ConnectionManager_rtcConnectionManager = new WeakMap();\n\n/**\n * Entry points for the `Channel` subset of the `InterApplicationBus` API (`fin.InterApplicationBus.Channel`).\n *\n * * {@link Channel} contains static members of the `Channel` API, accessible through `fin.InterApplicationBus.Channel`.\n * * {@link OpenFin.ChannelClient} describes a client of a channel, e.g. as returned by `fin.InterApplicationBus.Channel.connect`.\n * * {@link OpenFin.ChannelProvider} describes a provider of a channel, e.g. as returned by `fin.InterApplicationBus.Channel.create`.\n *\n * @packageDocumentation\n */\nvar __classPrivateFieldSet$4 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar __classPrivateFieldGet$6 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar _Channel_connectionManager, _Channel_internalEmitter, _Channel_readyToConnect;\nObject.defineProperty(channel$1, \"__esModule\", { value: true });\nchannel$1.Channel = void 0;\n/* eslint-disable no-console */\nconst events_1$5 = require$$0;\nconst lazy_1$1 = lazy;\nconst base_1$e = base;\nconst client_1 = client;\nconst connection_manager_1 = connectionManager;\nconst provider_1 = provider;\nfunction retryDelay(count) {\n    const interval = 500; // base delay\n    const steps = 10; // How many retries to do before incrementing the delay\n    const base = 2; // How much to multiply the previous delay by\n    const max = 30000; // max delay\n    const step = Math.floor(count / steps);\n    const delay = Math.min(max, interval * base ** step);\n    return new Promise((resolve) => {\n        setTimeout(() => {\n            resolve(false);\n        }, delay);\n    });\n}\n/**\n * The Channel API allows an OpenFin application to create a channel as a {@link ChannelProvider ChannelProvider},\n * or connect to a channel as a {@link ChannelClient ChannelClient}.\n * @remarks The \"handshake\" between the communication partners is\n * simplified when using a channel.  A request to connect to a channel as a client will return a promise that resolves if/when the channel has been created. Both the\n * provider and client can dispatch actions that have been registered on their opposites, and dispatch returns a promise that resolves with a payload from the other\n * communication participant. There can be only one provider per channel, but many clients.  Version `9.61.35.*` or later is required for both communication partners.\n *\n * Asynchronous Methods:\n *  * {@link Channel.create create(channelName, options)}\n *  * {@link Channel.connect connect(channelName, options)}\n *  * {@link Channel.onChannelConnect onChannelConnect(listener)}\n *  * {@link Channel.onChannelDisconnect onChannelDisconnect(listener)}\n */\nclass Channel extends base_1$e.EmitterBase {\n    /**\n     * @internal\n     */\n    constructor(wire) {\n        super(wire, 'channel');\n        _Channel_connectionManager.set(this, void 0);\n        _Channel_internalEmitter.set(this, new events_1$5.EventEmitter());\n        // OpenFin API has not been injected at construction time, *must* wait for API to be ready.\n        _Channel_readyToConnect.set(this, new lazy_1$1.AsyncRetryableLazy(async () => {\n            await Promise.all([\n                this.on('disconnected', (eventPayload) => {\n                    client_1.ChannelClient.handleProviderDisconnect(eventPayload);\n                }),\n                this.on('connected', (...args) => {\n                    __classPrivateFieldGet$6(this, _Channel_internalEmitter, \"f\").emit('connected', ...args);\n                })\n            ]).catch(() => new Error('error setting up channel connection listeners'));\n        }));\n        __classPrivateFieldSet$4(this, _Channel_connectionManager, new connection_manager_1.ConnectionManager(wire), \"f\");\n    }\n    /**\n     *\n     * @internal\n     */\n    async getAllChannels() {\n        return this.wire.sendAction('get-all-channels').then(({ payload }) => payload.data);\n    }\n    /**\n     * Listens for channel connections.\n     *\n     * @param listener - callback to execute.\n     *\n     * @example\n     *\n     * ```js\n     * const listener = (channelPayload) => console.log(channelPayload); // see return value below\n     *\n     * fin.InterApplicationBus.Channel.onChannelConnect(listener);\n     *\n     * // example shape\n     * {\n     *     \"topic\": \"channel\",\n     *     \"type\": \"connected\",\n     *     \"uuid\": \"OpenfinPOC\",\n     *     \"name\": \"OpenfinPOC\",\n     *     \"channelName\": \"counter\",\n     *     \"channelId\": \"OpenfinPOC/OpenfinPOC/counter\"\n     * }\n     *\n     * ```\n     */\n    async onChannelConnect(listener) {\n        await this.on('connected', listener);\n    }\n    /**\n     * Listen for channel disconnections.\n     *\n     * @param listener - callback to execute.\n     *\n     * @example\n     *\n     * ```js\n     * const listener = (channelPayload) => console.log(channelPayload); // see return value below\n     *\n     * fin.InterApplicationBus.Channel.onChannelDisconnect(listener);\n     *\n     * // example shape\n     * {\n     *     \"topic\": \"channel\",\n     *     \"type\": \"disconnected\",\n     *     \"uuid\": \"OpenfinPOC\",\n     *     \"name\": \"OpenfinPOC\",\n     *     \"channelName\": \"counter\",\n     *     \"channelId\": \"OpenfinPOC/OpenfinPOC/counter\"\n     * }\n     *\n     * ```\n     */\n    async onChannelDisconnect(listener) {\n        await this.on('disconnected', listener);\n    }\n    async safeConnect(channelName, shouldWait, connectPayload) {\n        const retryInfo = { count: 0 };\n        /* eslint-disable no-await-in-loop, no-constant-condition */\n        do {\n            // setup a listener and a connected promise to await in case we connect before the channel is ready\n            let connectedListener = () => undefined;\n            const connectedPromise = new Promise((resolve) => {\n                connectedListener = (payload) => {\n                    if (channelName === payload.channelName) {\n                        resolve(true);\n                    }\n                };\n                __classPrivateFieldGet$6(this, _Channel_internalEmitter, \"f\").on('connected', connectedListener);\n            });\n            try {\n                if (retryInfo.count > 0) {\n                    // Wait before retrying\n                    // Delay returns false connectedPromise returns true so we can know if a retry is due to connected event\n                    retryInfo.gotConnectedEvent = await Promise.race([retryDelay(retryInfo.count), connectedPromise]);\n                    const result = await this.wire.sendAction('connect-to-channel', { ...connectPayload, retryInfo });\n                    // log only if there was a retry\n                    console.log(`Successfully connected to channelName: ${channelName}`);\n                    return result.payload.data;\n                }\n                // Send retryInfo to the core for debug log inclusion\n                const sentMessagePromise = this.wire.sendAction('connect-to-channel', connectPayload);\n                // Save messageId from the first connection attempt\n                retryInfo.originalMessageId = sentMessagePromise.messageId;\n                const result = await sentMessagePromise;\n                return result.payload.data;\n            }\n            catch (error) {\n                if (!error.message.includes('internal-nack')) {\n                    // Not an internal nack, break the loop\n                    throw error;\n                }\n                if (shouldWait && retryInfo.count === 0) {\n                    // start waiting on the next iteration, warn the user\n                    console.warn(`No channel found for channelName: ${channelName}. Waiting for connection...`);\n                }\n            }\n            finally {\n                retryInfo.count += 1;\n                // in case of other errors, remove our listener\n                __classPrivateFieldGet$6(this, _Channel_internalEmitter, \"f\").removeListener('connected', connectedListener);\n            }\n        } while (shouldWait); // If we're waiting we retry the above loop\n        // Should wait was false, no channel was found.\n        throw new Error(`No channel found for channelName: ${channelName}.`);\n        /* eslint-enable no-await-in-loop, no-constant-condition */\n    }\n    /**\n     * Connect to a channel. If you wish to send a payload to the provider, add a payload property to the options argument.\n     * EXPERIMENTAL: pass { protocols: ['rtc'] } as options to opt-in to High Throughput Channels.\n     *\n     * @param channelName - Name of the target channel.\n     * @param options - Connection options.\n     * @returns Returns a promise that resolves with an instance of {@link ChannelClient ChannelClient}.\n     *\n     * @remarks The connection request will be routed to the channelProvider if/when the channel is created.  If the connect\n     * request is sent prior to creation, the promise will not resolve or reject until the channel is created by a channelProvider\n     * (whether or not to wait for creation is configurable in the connectOptions).\n     *\n     * The connect call returns a promise that will resolve with a channelClient bus if accepted by the channelProvider, or reject if\n     * the channelProvider throws an error to reject the connection. This bus can communicate with the Provider, but not to other\n     * clients on the channel. Using the bus, the channelClient can register actions and middleware. Channel lifecycle can also be\n     * handled with an onDisconnection listener.\n     *\n     * @example\n     *\n     * ```js\n     * async function makeClient(channelName) {\n     *    // A payload can be sent along with channel connection requests to help with authentication\n     *    const connectPayload = { payload: 'token' };\n     *\n     *    // If the channel has been created this request will be sent to the provider.  If not, the\n     *    // promise will not be resolved or rejected until the channel has been created.\n     *    const clientBus = await fin.InterApplicationBus.Channel.connect(channelName, connectPayload);\n     *\n     *    clientBus.onDisconnection(channelInfo => {\n     *        // handle the channel lifecycle here - we can connect again which will return a promise\n     *        // that will resolve if/when the channel is re-created.\n     *        makeClient(channelInfo.channelName);\n     *    })\n     *\n     *    clientBus.register('topic', (payload, identity) => {\n     *        // register a callback for a topic to which the channel provider can dispatch an action\n     *        console.log('Action dispatched by provider: ', JSON.stringify(identity));\n     *        console.log('Payload sent in dispatch: ', JSON.stringify(payload));\n     *        return {\n     *            echo: payload\n     *        };\n     *    });\n     * }\n     *\n     * makeClient('channelName')\n     * .then(() => console.log('Connected'))\n     * .catch(console.error);\n     * ```\n     */\n    async connect(channelName, options = {}) {\n        // Make sure we don't connect before listeners are set up\n        // This also errors if we're not in OpenFin, ensuring we don't run unnecessary code\n        await __classPrivateFieldGet$6(this, _Channel_readyToConnect, \"f\").getValue();\n        if (!channelName || typeof channelName !== 'string') {\n            throw new Error('Please provide a channelName string to connect to a channel.');\n        }\n        const opts = { wait: true, ...this.wire.environment.getDefaultChannelOptions().connect, ...options };\n        const { offer, rtc: rtcPacket } = await __classPrivateFieldGet$6(this, _Channel_connectionManager, \"f\").createClientOffer(opts);\n        let connectionUrl;\n        if (this.fin.me.isFrame || this.fin.me.isView || this.fin.me.isWindow) {\n            connectionUrl = (await this.fin.me.getInfo()).url;\n        }\n        const connectPayload = {\n            channelName,\n            ...opts,\n            offer,\n            connectionUrl\n        };\n        const routingInfo = await this.safeConnect(channelName, opts.wait, connectPayload);\n        const strategy = await __classPrivateFieldGet$6(this, _Channel_connectionManager, \"f\").createClientStrategy(rtcPacket, routingInfo);\n        const channel = new client_1.ChannelClient(routingInfo, () => client_1.ChannelClient.wireClose(this.wire, routingInfo, routingInfo.endpointId), strategy);\n        // It is the client's responsibility to handle endpoint disconnection to the provider.\n        // If the endpoint dies, the client will force a disconnection through the core.\n        // The provider does not care about endpoint disconnection.\n        strategy.onEndpointDisconnect(routingInfo.channelId, async () => {\n            try {\n                await channel.sendDisconnectAction();\n            }\n            catch (error) {\n                console.warn(`Something went wrong during disconnect for client with uuid: ${routingInfo.uuid} / name: ${routingInfo.name} / endpointId: ${routingInfo.endpointId}.`);\n            }\n            finally {\n                client_1.ChannelClient.handleProviderDisconnect(routingInfo);\n            }\n        });\n        return channel;\n    }\n    /**\n     * Create a new channel.\n     * You must provide a unique channelName. If a channelName is not provided, or it is not unique, the creation will fail.\n     * EXPERIMENTAL: pass { protocols: ['rtc'] } as options to opt-in to High Throughput Channels.\n     *\n     * @param channelName - Name of the channel to be created.\n     * @param options - Creation options.\n     * @returns Returns a promise that resolves with an instance of {@link ChannelProvider ChannelProvider}.\n     *\n     * @remarks If successful, the create method returns a promise that resolves to an instance of the channelProvider bus. The caller\n     * then becomes the “channel provider” and can use the channelProvider bus to register actions and middleware.\n     *\n     * The caller can also set an onConnection and/or onDisconnection listener that will execute on any new channel\n     * connection/disconnection attempt from a channel client. To reject a connection, simply throw an error in the\n     * onConnection listener.  The default behavior is to accept all new connections.\n     *\n     * A map of client connections is updated automatically on client connection and disconnection and saved in the\n     * [read-only] `connections` property on the channelProvider bus.  The channel will exist until the provider\n     * destroys it or disconnects by closing or destroying the context (navigating or reloading). To setup a channel\n     * as a channelProvider, call `Channel.create` with a unique channel name. A map of client connections is updated\n     * automatically on client connection and disconnection.\n     *\n     * @example\n     *\n     * ```js\n     * (async ()=> {\n     *    // entity creates a channel and becomes the channelProvider\n     *    const providerBus = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *    providerBus.onConnection((identity, payload) => {\n     *        // can reject a connection here by throwing an error\n     *        console.log('Client connection request identity: ', JSON.stringify(identity));\n     *        console.log('Client connection request payload: ', JSON.stringify(payload));\n     *    });\n     *\n     *    providerBus.register('topic', (payload, identity) => {\n     *        // register a callback for a 'topic' to which clients can dispatch an action\n     *        console.log('Action dispatched by client: ', JSON.stringify(identity));\n     *        console.log('Payload sent in dispatch: ', JSON.stringify(payload));\n     *        return {\n     *            echo: payload\n     *        };\n     *    });\n     * })();\n     * ```\n     */\n    async create(channelName, options) {\n        if (!channelName) {\n            throw new Error('Please provide a channelName to create a channel');\n        }\n        const { payload: { data: providerIdentity } } = await this.wire.sendAction('create-channel', { channelName });\n        const channel = __classPrivateFieldGet$6(this, _Channel_connectionManager, \"f\").createProvider(options, providerIdentity);\n        // TODO: fix typing (internal)\n        // @ts-expect-error\n        this.on('client-disconnected', (eventPayload) => {\n            if (eventPayload.channelName === channelName) {\n                provider_1.ChannelProvider.handleClientDisconnection(channel, eventPayload);\n            }\n        });\n        return channel;\n    }\n}\nchannel$1.Channel = Channel;\n_Channel_connectionManager = new WeakMap(), _Channel_internalEmitter = new WeakMap(), _Channel_readyToConnect = new WeakMap();\n\nObject.defineProperty(interappbus, \"__esModule\", { value: true });\ninterappbus.InterAppPayload = interappbus.InterApplicationBus = void 0;\n/**\n * Entry point for the OpenFin `InterApplicationBus` API (`fin.InterApplicationBus`).\n *\n * * {@link InterApplicationBus} contains static members of the `InterApplicationBus` API, accessible through `fin.InterApplicationBus`.\n *\n * @packageDocumentation\n */\nconst events_1$4 = require$$0;\nconst base_1$d = base;\nconst ref_counter_1 = refCounter;\nconst index_1$2 = channel$1;\nconst validate_1$3 = validate;\n/**\n * A messaging bus that allows for pub/sub messaging between different applications.\n *\n */\nclass InterApplicationBus extends base_1$d.Base {\n    /**\n     * @internal\n     */\n    constructor(wire) {\n        super(wire);\n        this.events = {\n            subscriberAdded: 'subscriber-added',\n            subscriberRemoved: 'subscriber-removed'\n        };\n        this.refCounter = new ref_counter_1.RefCounter();\n        this.Channel = new index_1$2.Channel(wire);\n        this.emitter = new events_1$4.EventEmitter();\n        wire.registerMessageHandler(this.onmessage.bind(this));\n        this.on = this.emitter.on.bind(this.emitter);\n        this.removeAllListeners = this.emitter.removeAllListeners.bind(this.emitter);\n    }\n    /**\n     * Publishes a message to all applications running on OpenFin Runtime that\n     * are subscribed to the specified topic.\n     * @param topic The topic on which the message is sent\n     * @param message The message to be published. Can be either a primitive\n     * data type (string, number, or boolean) or composite data type (object, array)\n     * that is composed of other primitive or composite data types\n     *\n     * @example\n     * ```js\n     * fin.InterApplicationBus.publish('topic', 'hello').then(() => console.log('Published')).catch(err => console.log(err));\n     * ```\n     */\n    async publish(topic, message) {\n        await this.wire.sendAction('publish-message', {\n            topic,\n            message,\n            sourceWindowName: this.me.name\n        });\n    }\n    /**\n     * Sends a message to a specific application on a specific topic.\n     * @param destination The identity of the application to which the message is sent\n     * @param topic The topic on which the message is sent\n     * @param message The message to be sent. Can be either a primitive data\n     * type (string, number, or boolean) or composite data type (object, array) that\n     * is composed of other primitive or composite data types\n     *\n     * @example\n     * ```js\n     * fin.InterApplicationBus.send(fin.me, 'topic', 'Hello there!').then(() => console.log('Message sent')).catch(err => console.log(err));\n     * ```\n     */\n    async send(destination, topic, message) {\n        const errorMsg = (0, validate_1$3.validateIdentity)(destination);\n        if (errorMsg) {\n            throw new Error(errorMsg);\n        }\n        await this.wire.sendAction('send-message', {\n            destinationUuid: destination.uuid,\n            destinationWindowName: destination.name,\n            topic,\n            message,\n            sourceWindowName: this.me.name\n        });\n    }\n    /**\n     * Subscribes to messages from the specified application on the specified topic.\n     * @param source This object is described in the Identity in the typedef\n     * @param topic The topic on which the message is sent\n     * @param listener A function that is called when a message has\n     * been received. It is passed the message, uuid and name of the sending application.\n     * The message can be either a primitive data type (string, number, or boolean) or\n     * composite data type (object, array) that is composed of other primitive or composite\n     * data types\n     *\n     * @example\n     * ```js\n     * // subscribe to a specified application\n     * fin.InterApplicationBus.subscribe(fin.me, 'topic', sub_msg => console.log(sub_msg)).then(() => console.log('Subscribed to the specified application')).catch(err => console.log(err));\n     *\n     * // subscribe to wildcard\n     * fin.InterApplicationBus.subscribe({ uuid: '*' }, 'topic', sub_msg => console.log(sub_msg)).then(() => console.log('Subscribed to *')).catch(err => console.log(err));\n     * ```\n     */\n    subscribe(source, topic, listener) {\n        const subKey = this.createSubscriptionKey(source.uuid, source.name || '*', topic);\n        const sendSubscription = async () => {\n            await this.wire.sendAction('subscribe', {\n                sourceUuid: source.uuid,\n                sourceWindowName: source.name || '*',\n                topic,\n                destinationWindowName: this.me.name\n            });\n        };\n        const alreadySubscribed = () => {\n            return Promise.resolve();\n        };\n        this.emitter.on(subKey, listener);\n        return this.refCounter.actOnFirst(subKey, sendSubscription, alreadySubscribed);\n    }\n    /**\n     * Unsubscribes to messages from the specified application on the specified topic.\n     *\n     * @remarks If you are listening to all apps on a topic, (i.e you passed `{ uuid:'*' }` to the subscribe function)\n     * then you need to pass `{ uuid:'*' }` to unsubscribe as well. If you are listening to a specific application,\n     * (i.e you passed `{ uuid:'some_app' }` to the subscribe function) then you need to provide the same identifier to\n     * unsubscribe, unsubscribing to `*` on that same topic will not unhook your initial listener otherwise.\n     *\n     * @param source This object is described in the Identity in the typedef\n     * @param topic The topic on which the message is sent\n     * @param listener A callback previously registered with subscribe()\n     *\n     * @example\n     * ```js\n     * const listener = console.log;\n     *\n     * // If any application publishes a message on topic `foo`, our listener will be called.\n     * await fin.InterApplicationBus.subscribe({ uuid:'*' }, 'foo', listener)\n     *\n     * // When you want to unsubscribe, you need to specify the uuid of the app you'd like to\n     * // unsubscribe from (or `*`) and provide the same function you gave the subscribe function\n     * await fin.InterApplicationBus.unsubscribe({ uuid:'*' }, 'foo', listener)\n     * ```\n     */\n    unsubscribe(source, topic, listener) {\n        const sourceWindowName = source.name || '*';\n        const subKey = this.createSubscriptionKey(source.uuid, sourceWindowName, topic);\n        const sendUnsubscription = async () => {\n            await this.wire.sendAction('unsubscribe', {\n                sourceUuid: source.uuid,\n                sourceWindowName,\n                topic,\n                destinationWindowName: this.me.name\n            });\n        };\n        const dontSendUnsubscription = () => {\n            return new Promise((r) => r).then(() => undefined);\n        };\n        this.emitter.removeListener(subKey, listener);\n        return this.refCounter.actOnLast(subKey, sendUnsubscription, dontSendUnsubscription);\n    }\n    processMessage(message) {\n        const { payload: { message: payloadMessage, sourceWindowName, sourceUuid, topic } } = message;\n        const keys = [\n            this.createSubscriptionKey(sourceUuid, sourceWindowName, topic),\n            this.createSubscriptionKey(sourceUuid, '*', topic),\n            this.createSubscriptionKey('*', '*', topic)\n        ];\n        const idOfSender = { uuid: sourceUuid, name: sourceWindowName };\n        keys.forEach((key) => {\n            this.emitter.emit(key, payloadMessage, idOfSender);\n        });\n    }\n    emitSubscriverEvent(type, message) {\n        const { payload: { targetName: name, uuid, topic } } = message;\n        const payload = { name, uuid, topic };\n        this.emitter.emit(type, payload);\n    }\n    // eslint-disable-next-line class-methods-use-this\n    createSubscriptionKey(uuid, name, topic) {\n        const n = name || '*';\n        if (!(uuid && n && topic)) {\n            throw new Error('Missing uuid, name, or topic string');\n        }\n        return createKey(uuid, n, topic);\n    }\n    onmessage(message) {\n        const { action } = message;\n        switch (action) {\n            case 'process-message':\n                this.processMessage(message);\n                break;\n            case this.events.subscriberAdded:\n                this.emitSubscriverEvent(this.events.subscriberAdded, message);\n                break;\n            case this.events.subscriberRemoved:\n                this.emitSubscriverEvent(this.events.subscriberRemoved, message);\n                break;\n        }\n        return true;\n    }\n}\ninterappbus.InterApplicationBus = InterApplicationBus;\n/**\n * @internal\n */\nclass InterAppPayload {\n}\ninterappbus.InterAppPayload = InterAppPayload;\nfunction createKey(...toHash) {\n    return toHash\n        .map((item) => {\n        return Buffer.from(`${item}`).toString('base64');\n    })\n        .join('/');\n}\n\nvar clipboard = {};\n\n/**\n * Entry point for the OpenFin `Clipboard` API (`fin.Clipboard`).\n *\n * * {@link Clipboard} contains static members of the `Clipboard` API, accessible through `fin.Clipboard`.\n *\n * @packageDocumentation\n */\nObject.defineProperty(clipboard, \"__esModule\", { value: true });\nclipboard.Clipboard = void 0;\nconst base_1$c = base;\n/**\n * The Clipboard API allows reading and writing to the clipboard in multiple formats.\n *\n */\nclass Clipboard extends base_1$c.Base {\n    /**\n     * Writes data into the clipboard as plain text\n     * @param writeObj The object for writing data into the clipboard\n     *\n     * @example\n     * ```js\n     * fin.Clipboard.writeText({\n     *     data: 'hello, world'\n     * }).then(() => console.log('Text On clipboard')).catch(err => console.log(err));\n     * ```\n     */\n    async writeText(writeObj) {\n        await this.wire.sendAction('clipboard-write-text', writeObj);\n    }\n    /**\n     * Read the content of the clipboard as plain text\n     * @param type Clipboard Type defaults to 'clipboard', use 'selection' for linux\n     *\n     * @example\n     * ```js\n     * fin.Clipboard.readText().then(text => console.log(text)).catch(err => console.log(err));\n     * ```\n     */\n    async readText(type) {\n        // NOTE: When we start supporting linux, we could detect the OS and choose 'selection' automatically for the user\n        const { payload } = await this.wire.sendAction('clipboard-read-text', { type });\n        return payload.data;\n    }\n    /**\n     * Writes data into the clipboard as an Image\n     * @param writeRequest The object to write an image to the clipboard\n     *\n     * @example\n     * ```js\n     * fin.Clipboard.writeImage({\n     *   // raw base64 string, or dataURL of either data:image/png or data:image/jpeg type\n     *   image: '...'\n     * }).then(() => console.log('Image written to clipboard')).catch(err => console.log(err));\n     * ```\n     */\n    async writeImage(writeRequest) {\n        await this.wire.sendAction('clipboard-write-image', writeRequest);\n    }\n    /**\n     * Read the content of the clipboard as a base64 string or a dataURL based on the input parameter 'format', defaults to 'dataURL'\n     * @param readRequest Clipboard Read Image request with formatting options\n     *\n     * @example\n     * ```js\n     * // see TS type: OpenFin.ImageFormatOptions\n     *\n     * const pngOrDataURLOrBmpOptions = {\n     *     format: 'png', // can be: 'png' | 'dataURL' | 'bmp'\n     * };\n     *\n     * const jpgOptions = {\n     *     format: 'jpg',\n     *     quality: 80 // optional, if omitted defaults to 100\n     * };\n     *\n     * fin.Clipboard.readImage(pngOrDataURLOrBmpOptions)\n     *     .then(image => console.log('Image read from clipboard as PNG, DataURL or BMP', image))\n     *     .catch(err => console.log(err));\n     *\n     * fin.Clipboard.readImage(jpgOptions)\n     *     .then(image => console.log('Image read from clipboard as JPG', image))\n     *     .catch(err => console.log(err));\n     *\n     * // defaults to {format: 'dataURL'}\n     * fin.Clipboard.readImage()\n     *     .then(image => console.log('Image read from clipboard as DataURL', image))\n     *     .catch(err => console.log(err));\n     *\n     * ```\n     */\n    async readImage(readRequest = { format: 'dataURL' }) {\n        const { payload } = await this.wire.sendAction('clipboard-read-image', readRequest);\n        return payload.data;\n    }\n    /**\n     * Writes data into the clipboard as Html\n     * @param writeObj The object for writing data into the clipboard\n     *\n     * @example\n     * ```js\n     * fin.Clipboard.writeHtml({\n     *         data: '<h1>Hello, World!</h1>'\n     * }).then(() => console.log('HTML On clipboard')).catch(err => console.log(err));\n     * ```\n     */\n    async writeHtml(writeObj) {\n        await this.wire.sendAction('clipboard-write-html', writeObj);\n    }\n    /**\n     * Read the content of the clipboard as Html\n     * @param type Clipboard Type defaults to 'clipboard', use 'selection' for linux\n     *\n     * @example\n     * ```js\n     * fin.Clipboard.readHtml().then(html => console.log(html)).catch(err => console.log(err));\n     * ```\n     */\n    async readHtml(type) {\n        const { payload } = await this.wire.sendAction('clipboard-read-html', { type });\n        return payload.data;\n    }\n    /**\n     * Writes data into the clipboard as Rtf\n     * @param writeObj The object for writing data into the clipboard\n     *\n     * @example\n     * ```js\n     * fin.Clipboard.writeRtf({\n     *         data: 'some text goes here'\n     * }).then(() => console.log('RTF On clipboard')).catch(err => console.log(err));\n     * ```\n     */\n    async writeRtf(writeObj) {\n        await this.wire.sendAction('clipboard-write-rtf', writeObj);\n    }\n    /**\n     * Read the content of the clipboard as Rtf\n     * @param type Clipboard Type defaults to 'clipboard', use 'selection' for linux\n     *\n     * @example\n     *\n     * ```js\n     * const writeObj = {\n     *     data: 'some text goes here'\n     * };\n     * async function readRtf() {\n     *     await fin.Clipboard.writeRtf(writeObj);\n     *     return await fin.Clipboard.readRtf();\n     * }\n     * readRtf().then(rtf => console.log(rtf)).catch(err => console.log(err));\n     * ```\n     */\n    async readRtf(type) {\n        const { payload } = await this.wire.sendAction('clipboard-read-rtf', { type });\n        return payload.data;\n    }\n    /**\n     * Writes data into the clipboard\n     * @param writeObj The object for writing data into the clipboard\n     *\n     * @example\n     * ```js\n     * fin.Clipboard.write({\n     *   data: {\n     *     text: 'a',\n     *     html: 'b',\n     *     rtf: 'c',\n     *     // Can be either a base64 string, or a DataURL string. If using DataURL, the\n     *     // supported formats are `data:image/png[;base64],` and `data:image/jpeg[;base64],`.\n     *     // Using other image/<format> DataURLs will throw an Error.\n     *     image: '...'\n     *   }\n     * }).then(() => console.log('write data into clipboard')).catch(err => console.log(err));\n     * ```\n     */\n    async write(writeObj) {\n        await this.wire.sendAction('clipboard-write', writeObj);\n    }\n    /**\n     * Reads available formats for the clipboard type\n     * @param type Clipboard Type defaults to 'clipboard', use 'selection' for linux\n     *\n     * @example\n     * ```js\n     * fin.Clipboard.getAvailableFormats().then(formats => console.log(formats)).catch(err => console.log(err));\n     * ```\n     */\n    async getAvailableFormats(type) {\n        const { payload } = await this.wire.sendAction('clipboard-read-formats', { type });\n        return payload.data;\n    }\n}\nclipboard.Clipboard = Clipboard;\n\nvar externalApplication = {};\n\nvar Factory$5 = {};\n\nvar Instance$4 = {};\n\nObject.defineProperty(Instance$4, \"__esModule\", { value: true });\nInstance$4.ExternalApplication = void 0;\n/* eslint-disable import/prefer-default-export */\nconst base_1$b = base;\n/**\n * An ExternalApplication object representing native language adapter connections to the runtime. Allows\n * the developer to listen to {@link OpenFin.ExternalApplicationEvents external application events}.\n * Discovery of connections is provided by {@link System.System.getAllExternalApplications getAllExternalApplications}.</a>\n *\n * Processes that can be wrapped as `ExternalApplication`s include the following:\n * - Processes which have connected to an OpenFin runtime via an adapter\n * - Processes started via `System.launchExternalApplication`\n * - Processes monitored via `System.monitorExternalProcess`\n */\nclass ExternalApplication extends base_1$b.EmitterBase {\n    /**\n     * @internal\n     */\n    constructor(wire, identity) {\n        super(wire, 'external-application', identity.uuid);\n        this.identity = identity;\n    }\n    /**\n     * Retrieves information about the external application.\n     *\n     * @example\n     * ```js\n     * async function getInfo() {\n     *     const extApp = await fin.ExternalApplication.wrap('javaApp-uuid');\n     *     return await extApp.getInfo();\n     * }\n     * getInfo().then(info => console.log(info)).catch(err => console.log(err));\n     * ```\n     */\n    getInfo() {\n        return this.wire.sendAction('get-external-application-info', this.identity).then(({ payload }) => payload.data);\n    }\n}\nInstance$4.ExternalApplication = ExternalApplication;\n\nObject.defineProperty(Factory$5, \"__esModule\", { value: true });\nFactory$5.ExternalApplicationModule = void 0;\nconst base_1$a = base;\nconst Instance_1$4 = Instance$4;\n/**\n * Static namespace for OpenFin API methods that interact with the {@link ExternalApplication} class, available under `fin.ExternalApplication`.\n */\nclass ExternalApplicationModule extends base_1$a.Base {\n    /**\n     * Asynchronously returns an External Application object that represents an external application.\n     * <br>It is possible to wrap a process that does not yet exist, (for example, to listen for startup-related events)\n     * provided its uuid is already known.\n     * @param uuid The UUID of the external application to be wrapped\n     *\n     * @example\n     * ```js\n     * fin.ExternalApplication.wrap('javaApp-uuid');\n     * .then(extApp => console.log('wrapped external application'))\n     * .catch(err => console.log(err));\n     * ```\n     */\n    wrap(uuid) {\n        this.wire.sendAction('external-application-wrap').catch((e) => {\n            // we do not want to expose this error, just continue if this analytics-only call fails\n        });\n        return Promise.resolve(new Instance_1$4.ExternalApplication(this.wire, { uuid }));\n    }\n    /**\n     * Synchronously returns an External Application object that represents an external application.\n     * <br>It is possible to wrap a process that does not yet exist, (for example, to listen for startup-related events)\n     * provided its uuid is already known.\n     * @param uuid The UUID of the external application to be wrapped\n     *\n     * @example\n     * ```js\n     * const extApp = fin.ExternalApplication.wrapSync('javaApp-uuid');\n     * const info = await extApp.getInfo();\n     * console.log(info);\n     * ```\n     */\n    wrapSync(uuid) {\n        this.wire.sendAction('external-application-wrap-sync').catch((e) => {\n            // we do not want to expose this error, just continue if this analytics-only call fails\n        });\n        return new Instance_1$4.ExternalApplication(this.wire, { uuid });\n    }\n}\nFactory$5.ExternalApplicationModule = ExternalApplicationModule;\n\n(function (exports) {\n\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t    }\n\t    Object.defineProperty(o, k2, desc);\n\t}) : (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    o[k2] = m[k];\n\t}));\n\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t};\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t/**\n\t * Entry points for the OpenFin `ExternalApplication` API (`fin.ExternalApplication`).\n\t *\n\t * * {@link ExternalApplicationModule} contains static members of the `ExternalApplication` type, accessible through `fin.ExternalApplication`.\n\t * * {@link ExternalApplication} describes an instance of an OpenFin ExternalApplication, e.g. as returned by `fin.ExternalApplication.getCurrent`.\n\t *\n\t * These are separate code entities, and are documented separately.  In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/32.114.76.10/index.html),\n\t * both of these were documented on the same page.\n\t *\n\t * @packageDocumentation\n\t */\n\t__exportStar(Factory$5, exports);\n\t__exportStar(Instance$4, exports); \n} (externalApplication));\n\nvar frame = {};\n\nvar Factory$4 = {};\n\nvar Instance$3 = {};\n\nObject.defineProperty(Instance$3, \"__esModule\", { value: true });\nInstance$3._Frame = void 0;\n/* eslint-disable import/prefer-default-export */\nconst base_1$9 = base;\n/**\n * An iframe represents an embedded HTML page within a parent HTML page. Because this embedded page\n * has its own DOM and global JS context (which may or may not be linked to that of the parent depending\n * on if it is considered out of the root domain or not), it represents a unique endpoint as an OpenFin\n * connection. Iframes may be generated dynamically, or be present on initial page load and each non-CORS\n * iframe has the OpenFin API injected by default. It is possible to opt into cross-origin iframes having\n * the API by setting api.iframe.crossOriginInjection to true in a window's options. To block all iframes\n * from getting the API injected you can set api.frame.sameOriginInjection\n * to false <a href=\"Window.html#~options\" target=\"_blank\">({@link OpenFin.WindowCreationOptions see Window Options})</a>.\n *\n * To be able to directly address this context for eventing and messaging purposes, it needs a\n * unique uuid name pairing. For OpenFin applications and windows this is provided via a configuration\n * object in the form of a manifest URL or options object, but there is no configuration object for iframes.\n * Just as a call to window.open outside of our Window API returns a new window with a random GUID assigned\n * for the name, each iframe that has the API injected will be assigned a GUID as its name, the UUID will be\n * the same as the parent window's.\n *\n * The fin.Frame namespace represents a way to interact with `iframes` and facilitates the discovery of current context\n * (iframe or main window) as well as the ability to listen for {@link OpenFin.FrameEvents frame-specific events}.\n */\nclass _Frame extends base_1$9.EmitterBase {\n    /**\n     * @internal\n     */\n    constructor(wire, identity) {\n        super(wire, 'frame', identity.uuid, identity.name);\n        this.identity = identity;\n    }\n    /**\n     * Returns a frame info object for the represented frame.\n     *\n     * @example\n     * ```js\n     * async function getInfo() {\n     *     const frm = await fin.Frame.getCurrent();\n     *     return await frm.getInfo();\n     * }\n     * getInfo().then(info => console.log(info)).catch(err => console.log(err));\n     * ```\n     */\n    getInfo() {\n        return this.wire.sendAction('get-frame-info', this.identity).then(({ payload }) => payload.data);\n    }\n    /**\n     * Returns a frame info object representing the window that the referenced iframe is\n     * currently embedded in.\n     *\n     * @remarks If the frame is embedded in a view, this will return an invalid stub with empty fields.\n     *\n     * @example\n     * ```js\n     * async function getParentWindow() {\n     *     const frm = await fin.Frame.getCurrent();\n     *     return await frm.getParentWindow();\n     * }\n     * getParentWindow().then(winInfo => console.log(winInfo)).catch(err => console.log(err));\n     * ```\n     */\n    getParentWindow() {\n        return this.wire.sendAction('get-parent-window', this.identity).then(({ payload }) => payload.data);\n    }\n}\nInstance$3._Frame = _Frame;\n\nObject.defineProperty(Factory$4, \"__esModule\", { value: true });\nFactory$4._FrameModule = void 0;\nconst base_1$8 = base;\nconst validate_1$2 = validate;\nconst Instance_1$3 = Instance$3;\n/**\n * Static namespace for OpenFin API methods that interact with the {@link _Frame} class, available under `fin.Frame`.\n */\nclass _FrameModule extends base_1$8.Base {\n    /**\n     * Asynchronously returns an API handle for the given Frame identity.\n     *\n     * @remarks Wrapping a Frame identity that does not yet exist will *not* throw an error, and instead\n     * returns a stub object that cannot yet perform rendering tasks. This can be useful for plumbing eventing\n     * for a Frame throughout its entire lifecycle.\n     *\n     * @example\n     * ```js\n     * fin.Frame.wrap({ uuid: 'testFrame', name: 'testFrame' })\n     * .then(frm => console.log('wrapped frame'))\n     * .catch(err => console.log(err));\n     * ```\n     */\n    async wrap(identity) {\n        this.wire.sendAction('frame-wrap').catch((e) => {\n            // we do not want to expose this error, just continue if this analytics-only call fails\n        });\n        const errorMsg = (0, validate_1$2.validateIdentity)(identity);\n        if (errorMsg) {\n            throw new Error(errorMsg);\n        }\n        return new Instance_1$3._Frame(this.wire, identity);\n    }\n    /**\n     * Synchronously returns an API handle for the given Frame identity.\n     *\n     * @remarks Wrapping a Frame identity that does not yet exist will *not* throw an error, and instead\n     * returns a stub object that cannot yet perform rendering tasks. This can be useful for plumbing eventing\n     * for a Frame throughout its entire lifecycle.\n     *\n     * @example\n     * ```js\n     * const frm = fin.Frame.wrapSync({ uuid: 'testFrame', name: 'testFrame' });\n     * const info = await frm.getInfo();\n     * console.log(info);\n     * ```\n     */\n    wrapSync(identity) {\n        this.wire.sendAction('frame-wrap-sync').catch((e) => {\n            // we do not want to expose this error, just continue if this analytics-only call fails\n        });\n        const errorMsg = (0, validate_1$2.validateIdentity)(identity);\n        if (errorMsg) {\n            throw new Error(errorMsg);\n        }\n        return new Instance_1$3._Frame(this.wire, identity);\n    }\n    /**\n     * Asynchronously returns a reference to the current frame\n     *\n     * @example\n     * ```js\n     * fin.Frame.getCurrent()\n     * .then(frm => console.log('current frame'))\n     * .catch(err => console.log(err));\n     * ```\n     */\n    getCurrent() {\n        this.wire.sendAction('frame-get-current').catch((e) => {\n            // we do not want to expose this error, just continue if this analytics-only call fails\n        });\n        return Promise.resolve(new Instance_1$3._Frame(this.wire, this.wire.environment.getCurrentEntityIdentity()));\n    }\n    /**\n     * Synchronously returns a reference to the current frame\n     *\n     * @example\n     * ```js\n     * const frm = fin.Frame.getCurrentSync();\n     * const info = await frm.getInfo();\n     * console.log(info);\n     * ```\n     */\n    getCurrentSync() {\n        this.wire.sendAction('frame-get-current-sync').catch((e) => {\n            // we do not want to expose this error, just continue if this analytics-only call fails\n        });\n        return new Instance_1$3._Frame(this.wire, this.wire.environment.getCurrentEntityIdentity());\n    }\n}\nFactory$4._FrameModule = _FrameModule;\n\n(function (exports) {\n\t/**\n\t * Entry points for the OpenFin `Frame` API (`fin.Frame`).\n\t *\n\t * * {@link _FrameModule} contains static members of the `Frame` API, accessible through `fin.Frame`.\n\t * * {@link _Frame} describes an instance of an OpenFin Frame, e.g. as returned by `fin.Frame.getCurrent`.\n\t *\n\t * These are separate code entities, and are documented separately. In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/32.114.76.10/index.html),\n\t * both of these were documented on the same page.\n\t *\n\t * Underscore prefixing of OpenFin types that alias DOM entities will be fixed in a future version.\n\t *\n\t * @packageDocumentation\n\t */\n\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t    }\n\t    Object.defineProperty(o, k2, desc);\n\t}) : (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    o[k2] = m[k];\n\t}));\n\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t};\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t__exportStar(Factory$4, exports);\n\t__exportStar(Instance$3, exports); \n} (frame));\n\nvar globalHotkey = {};\n\nObject.defineProperty(globalHotkey, \"__esModule\", { value: true });\nglobalHotkey.GlobalHotkey = void 0;\nconst base_1$7 = base;\n/**\n * The GlobalHotkey module can register/unregister a global hotkeys.\n *\n */\nclass GlobalHotkey extends base_1$7.EmitterBase {\n    /**\n     * @internal\n     */\n    constructor(wire) {\n        super(wire, 'global-hotkey');\n    }\n    /**\n     * Registers a global hotkey with the operating system.\n     * @param hotkey a hotkey string\n     * @param listener called when the registered hotkey is pressed by the user.\n     * @throws If the `hotkey` is reserved, see list below.\n     * @throws if the `hotkey` is already registered by another application.\n     *\n     * @remarks The `hotkey` parameter expects an electron compatible [accelerator](https://github.com/electron/electron/blob/master/docs/api/accelerator.md) and the `listener` will be called if the `hotkey` is pressed by the user.\n     * If successfull, the hotkey will be 'claimed' by the application, meaning that this register call can be called multiple times from within the same application but will fail if another application has registered the hotkey.\n     * <br>The register call will fail if given any of these reserved Hotkeys:\n     * * `CommandOrControl+0`\n     * * `CommandOrControl+=`\n     * * `CommandOrControl+Plus`\n     * * `CommandOrControl+-`\n     * * `CommandOrControl+_`\n     * * `CommandOrControl+Shift+I`\n     * * `F5`\n     * * `CommandOrControl+R`\n     * * `Shift+F5`\n     * * `CommandOrControl+Shift+R`\n     *\n     * Raises the `registered` event.\n     *\n     * @example\n     * ```js\n     * const hotkey = 'CommandOrControl+X';\n     *\n     * fin.GlobalHotkey.register(hotkey, () => {\n     * console.log(`${hotkey} pressed`);\n     * })\n     * .then(() => {\n     *     console.log('Success');\n     * })\n     * .catch(err => {\n     *     console.log('Error registering the hotkey', err);\n     * });\n     * ```\n     */\n    async register(hotkey, listener) {\n        // TODO: fix typing (hotkey events are not typed)\n        // @ts-expect-error\n        await this.on(hotkey, listener);\n        await this.wire.sendAction('global-hotkey-register', { hotkey });\n        return undefined;\n    }\n    /**\n     * Unregisters a global hotkey with the operating system.\n     * @param hotkey a hotkey string\n     *\n     * @remarks This method will unregister all existing registrations of the hotkey within the application.\n     * Raises the `unregistered` event.\n     *\n     * @example\n     * ```js\n     * const hotkey = 'CommandOrControl+X';\n     *\n     * fin.GlobalHotkey.unregister(hotkey)\n     * .then(() => {\n     *     console.log('Success');\n     * })\n     * .catch(err => {\n     *     console.log('Error unregistering the hotkey', err);\n     * });\n     * ```\n     */\n    async unregister(hotkey) {\n        // TODO: fix typing (hotkey events are not typed)\n        // @ts-expect-error\n        await this.removeAllListeners(hotkey);\n        await this.wire.sendAction('global-hotkey-unregister', { hotkey });\n        return undefined;\n    }\n    /**\n     * Unregisters all global hotkeys for the current application.\n     *\n     * @remarks Raises the `unregistered` event for each hotkey unregistered.\n     *\n     * @example\n     * ```js\n     * fin.GlobalHotkey.unregisterAll()\n     * .then(() => {\n     *     console.log('Success');\n     * })\n     * .catch(err => {\n     *     console.log('Error unregistering all hotkeys for this application', err);\n     * });\n     * ```\n     */\n    async unregisterAll() {\n        await Promise.all(this.eventNames()\n            .filter((name) => !(name === 'registered' || name === 'unregistered'))\n            // TODO: fix typing (hotkey events are not typed)\n            // @ts-expect-error\n            .map((name) => this.removeAllListeners(name)));\n        await this.wire.sendAction('global-hotkey-unregister-all', {});\n        return undefined;\n    }\n    /**\n     * Checks if a given hotkey has been registered by an application within the current runtime.\n     * @param hotkey a hotkey string\n     *\n     * @example\n     * ```js\n     * const hotkey = 'CommandOrControl+X';\n     *\n     * fin.GlobalHotkey.isRegistered(hotkey)\n     * .then((registered) => {\n     *     console.log(`hotkey ${hotkey} is registered ? ${registered}`);\n     * })\n     * .catch(err => {\n     *     console.log('Error unregistering the hotkey', err);\n     * });\n     * ```\n     */\n    async isRegistered(hotkey) {\n        const { payload: { data } } = await this.wire.sendAction('global-hotkey-is-registered', { hotkey });\n        return data;\n    }\n}\nglobalHotkey.GlobalHotkey = GlobalHotkey;\n\nvar platform = {};\n\nvar Factory$3 = {};\n\nvar Instance$2 = {};\n\nvar __classPrivateFieldGet$5 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar _Platform_connectToProvider;\nObject.defineProperty(Instance$2, \"__esModule\", { value: true });\nInstance$2.Platform = void 0;\n/* eslint-disable import/prefer-default-export, no-undef */\nconst base_1$6 = base;\nconst validate_1$1 = validate;\n// Reuse clients to avoid overwriting already-registered client in provider\nconst clientMap = new Map();\n/** Manages the life cycle of windows and views in the application.\n *\n * Enables taking snapshots of itself and applying them to restore a previous configuration\n * as well as listen to {@link OpenFin.PlatformEvents platform events}.\n */\nclass Platform extends base_1$6.EmitterBase {\n    /**\n     * @internal\n     */\n    // eslint-disable-next-line no-shadow\n    constructor(identity, channel) {\n        // we piggyback off of application event emitter because from the core's perspective platform is just an app.\n        super(channel.wire, 'application', identity.uuid);\n        this.getClient = (identity) => {\n            this.wire.sendAction('platform-get-client', this.identity).catch((e) => {\n                // don't expose\n            });\n            const target = identity || this.identity;\n            const { uuid } = target;\n            if (!clientMap.has(uuid)) {\n                const clientPromise = __classPrivateFieldGet$5(this, _Platform_connectToProvider, \"f\").call(this, uuid);\n                clientMap.set(uuid, clientPromise);\n            }\n            // we set it above\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            return clientMap.get(uuid);\n        };\n        _Platform_connectToProvider.set(this, async (uuid) => {\n            try {\n                const channelName = `custom-frame-${uuid}`;\n                const client = await this._channel.connect(channelName, { wait: false });\n                client.onDisconnection(() => {\n                    clientMap.delete(uuid);\n                });\n                return client;\n            }\n            catch (e) {\n                clientMap.delete(uuid);\n                throw new Error('The targeted Platform is not currently running. Listen for application-started event for the given Uuid.');\n            }\n        });\n        /**\n         * @deprecated (renamed)\n         * @ignore\n         */\n        this.launchLegacyManifest = this.launchContentManifest;\n        const errorMsg = (0, validate_1$1.validateIdentity)(identity);\n        if (errorMsg) {\n            throw new Error(errorMsg);\n        }\n        this._channel = channel;\n        this.identity = { uuid: identity.uuid };\n        this.Layout = this.fin.Platform.Layout;\n        this.Application = this.fin.Application.wrapSync(this.identity);\n    }\n    /**\n     * Creates a new view and attaches it to a specified target window.\n     * @param viewOptions View creation options\n     * @param target The window to which the new view is to be attached. If no target, create a view in a new window.\n     * @param targetView If provided, the new view will be added to the same tabstrip as targetView.\n     *\n     * @remarks If the view already exists, will reparent the view to the new target. You do not need to set a name for a View.\n     * Views that are not passed a name get a randomly generated one.\n     *\n     * @example\n     * ```js\n     * let windowIdentity;\n     * if (fin.me.isWindow) {\n     *     windowIdentity = fin.me.identity;\n     * } else if (fin.me.isView) {\n     *     windowIdentity = (await fin.me.getCurrentWindow()).identity;\n     * } else {\n     *     throw new Error('Not running in a platform View or Window');\n     * }\n     *\n     * const platform = fin.Platform.getCurrentSync();\n     *\n     * platform.createView({\n     *     name: 'test_view',\n     *     url: 'https://developers.openfin.co/docs/platform-api'\n     * }, windowIdentity).then(console.log);\n     * ```\n     *\n     * Reparenting a view:\n     * ```js\n     * let windowIdentity;\n     * if (fin.me.isWindow) {\n     *     windowIdentity = fin.me.identity;\n     * } else if (fin.me.isView) {\n     *     windowIdentity = (await fin.me.getCurrentWindow()).identity;\n     * } else {\n     *     throw new Error('Not running in a platform View or Window');\n     * }\n     *\n     * let platform = fin.Platform.getCurrentSync();\n     * let viewOptions = {\n     *     name: 'example_view',\n     *     url: 'https://example.com'\n     * };\n     * // a new view will now show in the current window\n     * await platform.createView(viewOptions, windowIdentity);\n     *\n     * const view = fin.View.wrapSync({ uuid: windowIdentity.uuid, name: 'yahoo_view' });\n     * // reparent `example_view` when a view in the new window is shown\n     * view.on('shown', async () => {\n     *     let viewIdentity = { uuid: windowIdentity.uuid, name: 'example_view'};\n     *     let target = {uuid: windowIdentity.uuid, name: 'test_win'};\n     *     platform.createView(viewOptions, target);\n     * });\n     *\n     * // create a new window\n     * await platform.createWindow({\n     *     name: \"test_win\",\n     *     layout: {\n     *         content: [\n     *             {\n     *                 type: 'stack',\n     *                 content: [\n     *                     {\n     *                         type: 'component',\n     *                         componentName: 'view',\n     *                         componentState: {\n     *                             name: 'yahoo_view',\n     *                             url: 'https://yahoo.com'\n     *                         }\n     *                     }\n     *                 ]\n     *             }\n     *         ]\n     *     }\n     * }).then(console.log);\n     * ```\n     */\n    async createView(viewOptions, target, targetView) {\n        this.wire.sendAction('platform-create-view', this.identity).catch((e) => {\n            // don't expose\n        });\n        const client = await this.getClient();\n        const response = await client.dispatch('create-view', {\n            target,\n            opts: viewOptions,\n            targetView\n        });\n        if (!response || (0, validate_1$1.validateIdentity)(response.identity)) {\n            throw new Error(`When overwriting the createView call, please return an object that has a valid 'identity' property: ${JSON.stringify(response)}`);\n        }\n        return this.fin.View.wrapSync(response.identity);\n    }\n    /**\n     * Creates a new Window.\n     * @param options Window creation options\n     *\n     * @remarks There are two Window types at your disposal while using OpenFin Platforms - Default Window and Custom Window.\n     *\n     * The Default Window uses the standard OpenFin Window UI. It contains the standard close, maximize and minimize buttons,\n     * and will automatically render the Window's layout if one is specified.\n     *\n     * For deeper customization, you can bring your own Window code into a Platform. This is called a Custom Window.\n     *\n     * @example\n     *\n     *\n     * The example below will create a Default Window which uses OpenFin default Window UI.<br>\n     * The Window contains two Views in a stack Layout:\n     *\n     * ```js\n     * const platform = fin.Platform.getCurrentSync();\n     * platform.createWindow({\n     *     layout: {\n     *         content: [\n     *             {\n     *                 type: 'stack',\n     *                 content: [\n     *                     {\n     *                         type: 'component',\n     *                         componentName: 'view',\n     *                         componentState: {\n     *                             name: 'test_view_1',\n     *                             url: 'https://cdn.openfin.co/docs/javascript/canary/Platform.html'\n     *                         }\n     *                     },\n     *                     {\n     *                         type: 'component',\n     *                         componentName: 'view',\n     *                         componentState: {\n     *                             name: 'test_view_2',\n     *                             url: 'https://cdn.openfin.co/docs/javascript/canary/Platform.html'\n     *                         }\n     *                     }\n     *                 ]\n     *             }\n     *         ]\n     *     }\n     * }).then(console.log);\n     * ```\n     * The Default Window's design can be customized by specifying the `stylesheetUrl` property in the manifest:\n     *\n     * ```json\n     * {\n     *     platform: {\n     *         defaultWindowOptions: {\n     *             stylesheetUrl: 'some-url.css',\n     *             ...\n     *         }\n     *     }\n     * }\n     * ```\n     * For a list of common Layout CSS classes you can override in your custom stylesheet, see <a href=\"tutorial-layoutStyles.html\">Useful Layout CSS Classes</a>\n     **\n     * To specify a Platform Custom Window, provide a `url` property when creating a Window.\n     * If you intend to render a Layout in your Custom Window, you must also specify an `HTMLElement` that the Layout will inject into and set its `id` property to `\"layout-container\"`.\n     *\n     * The example below will create a Platform Custom Window:\n     *\n     * ```js\n     *     // in an OpenFin app:\n     *     const platform = fin.Platform.getCurrentSync();\n     *     const windowConfig =\n     *         {\n     *             url: \"https://www.my-domain.com/my-custom-window.html\", // here we point to where the Custom Frame is hosted.\n     *             layout: {\n     *                 content: [\n     *                     {\n     *                         type: \"stack\",\n     *                         content: [\n     *                             {\n     *                                 type: \"component\",\n     *                                 componentName: \"view\",\n     *                                 componentState: {\n     *                                     name: \"app #1\",\n     *                                     url: \"https://cdn.openfin.co/docs/javascript/canary/Platform.html\"\n     *                                 }\n     *                             },\n     *                             {\n     *                                 type: \"component\",\n     *                                 componentName: \"view\",\n     *                                 componentState: {\n     *                                     name: \"app #2\",\n     *                                     url: \"https://cdn.openfin.co/docs/javascript/canary/Platform.html\"\n     *                                 }\n     *                             }\n     *                         ]\n     *                     }\n     *                 ]\n     *             }\n     *         };\n     *     platform.createWindow(windowConfig);\n     * ```\n     *\n     * Here's an example of a minimalist Custom Platform Window implementation:\n     * ```html\n     * <html>\n     *     <head>\n     *         <meta charset=\"utf-8\">\n     *         <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n     *         <link rel=\"stylesheet\" type=\"text/css\" href=\"./styles.css\">\n     *     </head>\n     *     <body>\n     *         <div id=\"of-frame-main\">\n     *             <div id=\"title-bar\">\n     *                 <div class=\"title-bar-draggable\">\n     *                     <div id=\"title\"> This is a custom frame! </div>\n     *                 </div>\n     *                 <div id=\"buttons-wrapper\">\n     *                     <div class=\"button\" id=\"minimize-button\"></div>\n     *                     <div class=\"button\" id=\"expand-button\"></div>\n     *                     <div class=\"button\" id=\"close-button\"></div>\n     *                 </div>\n     *             </div>\n     *             <div id=\"layout-container\"></div> <!-- OpenFin layout would be injected here -->\n     *             <script src=\"./custom-frame.js\"></script>\n     *         </div>\n     *     </body>\n     * </html>\n     * ```\n     * Your Custom Window can use in-domain resources for further customization (such as CSS, scripts, etc.).<br>\n     * For a list of common Layout CSS classes you can override in your stylesheet, see <a href=\"tutorial-layoutStyles.html\">Useful Layout CSS Classes</a>\n     *\n     * The example above will require the `body` element to have `height: 100%;` set in order to render the layout correctly.\n     */\n    async createWindow(options) {\n        this.wire.sendAction('platform-create-window', this.identity).catch((e) => {\n            // don't expose\n        });\n        const client = await this.getClient();\n        if (!options.reason) {\n            options.reason = 'api-call';\n        }\n        const response = await client.dispatch('create-view-container', options);\n        if (!response || (0, validate_1$1.validateIdentity)(response.identity)) {\n            throw new Error(`When overwriting the createWindow call, please return an object that has a valid 'identity' property: ${JSON.stringify(response)}`);\n        }\n        const { identity } = response;\n        const res = this.fin.Window.wrapSync(identity);\n        // we add the identity at the top level for backwards compatibility.\n        res.name = identity.name;\n        res.uuid = identity.uuid;\n        return res;\n    }\n    /**\n     * Closes current platform, all its windows, and their views.\n     *\n     * @example\n     * ```js\n     * const platform = await fin.Platform.getCurrent();\n     * platform.quit();\n     * // All windows/views in current layout platform will close and platform will shut down\n     * ```\n     */\n    async quit() {\n        this.wire.sendAction('platform-quit', this.identity).catch((e) => {\n            // don't expose\n        });\n        const client = await this.getClient();\n        return client.dispatch('quit');\n    }\n    /**\n     * Closes a specified view in a target window.\n     * @param viewIdentity View identity\n     *\n     * @example\n     * ```js\n     * let windowIdentity;\n     * if (fin.me.isWindow) {\n     *     windowIdentity = fin.me.identity;\n     * } else if (fin.me.isView) {\n     *     windowIdentity = (await fin.me.getCurrentWindow()).identity;\n     * } else {\n     *     throw new Error('Not running in a platform View or Window');\n     * }\n     *\n     * const viewOptions = {\n     *     name: 'test_view',\n     *     url: 'https://example.com'\n     * };\n     *\n     * function sleep(ms) {\n     *     return new Promise(resolve => setTimeout(resolve, ms));\n     * }\n     *\n     * const platform = await fin.Platform.getCurrent();\n     *\n     * await platform.createView(viewOptions, windowIdentity);\n     * // a new view will now show in the current window\n     *\n     * await sleep(5000);\n     *\n     * const viewIdentity = { uuid: windowIdentity.uuid, name: 'test_view'};\n     * platform.closeView(viewIdentity);\n     * // the view will now close\n     * ```\n     */\n    async closeView(viewIdentity) {\n        this.wire.sendAction('platform-close-view', this.identity).catch((e) => {\n            // don't expose\n        });\n        const client = await this.getClient();\n        await client.dispatch('close-view', {\n            view: viewIdentity\n        });\n    }\n    /**\n     * ***DEPRECATED - please use {@link Platform.createView Platform.createView}.***\n     * Reparents a specified view in a new target window.\n     * @param viewIdentity View identity\n     * @param target new owner window identity\n     *\n     */\n    async reparentView(viewIdentity, target) {\n        // eslint-disable-next-line no-console\n        console.warn('Platform.reparentView has been deprecated, please use Platform.createView');\n        this.wire.sendAction('platform-reparent-view', this.identity).catch((e) => {\n            // don't expose\n        });\n        const normalizedViewIdentity = {\n            ...viewIdentity,\n            uuid: viewIdentity.uuid ?? this.identity.uuid\n        };\n        const view = await this.fin.View.wrap(normalizedViewIdentity);\n        const viewOptions = await view.getOptions();\n        return this.createView(viewOptions, target);\n    }\n    /**\n     * Returns a snapshot of the platform in its current state. You can pass the returning object to\n     * [Platform.applySnapshot]{@link Platform#applySnapshot} to launch it.\n     *\n     * @remarks The snapshot will include details such as an [ISO format](https://en.wikipedia.org/wiki/ISO_8601)\n     * timestamp of when the snapshot was taken, OpenFin runtime version the platform is running on, monitor information\n     * and the list of currently running windows.\n     *\n     * @example\n     * ```js\n     * const platform = await fin.Platform.getCurrent();\n     * const snapshot = await platform.getSnapshot();\n     * ```\n     */\n    async getSnapshot() {\n        this.wire.sendAction('platform-get-snapshot', this.identity).catch((e) => {\n            // don't expose\n        });\n        const client = await this.getClient();\n        return client.dispatch('get-snapshot');\n    }\n    /**\n     * **NOTE**: Internal use only. It is not recommended to manage the state of individual views.\n     *\n     * Returns a snapshot of a single view's options in its current state.\n     *\n     * Can be used to restore a view to a previous state.\n     *\n     * @param viewIdentity View identity\n     *\n     * @internal\n     * @experimental\n     * @remarks This slice of snapshot state is equivalent to what is stored as `componentState` for views\n     * when capturing platform state using [Platform.getSnapshot]{@link Platform#getSnapshot}.\n     *\n     * @example\n     * ```js\n     * const platform = await fin.Platform.getCurrent();\n     * const url = 'https://google.com';\n     * const view = await fin.View.create({ name: 'my-view', target: fin.me.identity, url });\n     *\n     * await view.navigate(url);\n     *\n     * const viewState = await platform.getViewSnapshot(view.identity);\n     *\n     * console.log(viewState);\n     * ```\n     */\n    async getViewSnapshot(viewIdentity) {\n        const client = await this.getClient();\n        return client.dispatch('get-view-snapshot', { viewIdentity });\n    }\n    /**\n     * Adds a snapshot to a running Platform.\n     * Requested snapshot must be a valid Snapshot object, or a url or filepath to such an object.\n     *\n     * Can optionally close existing windows and overwrite current platform state with that of a snapshot.\n     *\n     * The function accepts either a snapshot taken using {@link Platform#getSnapshot getSnapshot},\n     * or a url or filepath to a snapshot JSON object.\n     * @param requestedSnapshot Snapshot to apply, or a url or filepath.\n     * @param options Optional parameters to specify whether existing windows should be closed.\n     *\n     * @remarks Will create any windows and views that are not running but are passed in the snapshot object. Any View\n     * specified in the snapshot is assigned a randomly generated name to avoid collisions.\n     *\n     * @example\n     * ```js\n     * // Get a wrapped layout platform instance\n     * const platform = await fin.Platform.getCurrent();\n     *\n     * const snapshot = {\n     *     windows: [\n     *         {\n     *             layout: {\n     *                 content: [\n     *                     {\n     *                         type: 'stack',\n     *                         content: [\n     *                             {\n     *                                 type: 'component',\n     *                                 componentName: 'view',\n     *                                 componentState: {\n     *                                     name: 'component_X',\n     *                                     url: 'https://www.openfin.co'\n     *                                 }\n     *                             },\n     *                             {\n     *                                 type: 'component',\n     *                                 componentName: 'view',\n     *                                 componentState: {\n     *                                     name: 'component_Y',\n     *                                     url: 'https://cdn.openfin.co/embed-web/chart.html'\n     *                                 }\n     *                             }\n     *                         ]\n     *                     }\n     *                 ]\n     *             }\n     *         }\n     *     ]\n     * }\n     *\n     * platform.applySnapshot(snapshot);\n     * ```\n     *\n     * In place of a snapshot object, `applySnapshot` can take a url or filepath and to retrieve a JSON snapshot.\n     *\n     * ```js\n     * const platform = await fin.Platform.getCurrent();\n     * platform.applySnapshot('https://api.jsonbin.io/b/5e6f903ef4331e681fc1231d/1');\n     * ```\n     *\n     * Optionally, `applySnapshot` can close existing windows and restore a Platform to a previously saved state.\n     * This is accomplished by providing `{ closeExistingWindows: true }` as an option.\n     *\n     * ```js\n     * // Get a wrapped layout platform instance\n     * const platform = await fin.Platform.getCurrent();\n     *\n     * async function addViewToWindow(winId) {\n     *     return await platform.createView({\n     *         name: 'test_view_3',\n     *         url: 'https://openfin.co'\n     *     }, winId);\n     * }\n     *\n     * async function createWindowWithTwoViews() {\n     *     const platform = await fin.Platform.getCurrent();\n     *\n     *     return platform.createWindow({\n     *         layout: {\n     *             content: [\n     *                 {\n     *                     type: 'stack',\n     *                     content: [\n     *                         {\n     *                             type: 'component',\n     *                             componentName: 'view',\n     *                             componentState: {\n     *                                 name: 'test_view_1',\n     *                                 url: 'https://example.com'\n     *                             }\n     *                         },\n     *                         {\n     *                             type: 'component',\n     *                             componentName: 'view',\n     *                             componentState: {\n     *                                 name: 'test_view_2',\n     *                                 url: 'https://yahoo.com'\n     *                             }\n     *                         }\n     *                     ]\n     *                 }\n     *             ]\n     *         }\n     *     });\n     * }\n     *\n     * const win = await createWindowWithTwoViews();\n     * // ... you will now see a new window with two views in it\n     *\n     * // we take a snapshot of the current state of the app, before changing it\n     * const snapshotOfInitialAppState = await platform.getSnapshot();\n     *\n     * // now let's change the state of the app:\n     * await addViewToWindow(win.identity);\n     * // ... the window now has three views in it\n     *\n     * await platform.applySnapshot(snapshotOfInitialAppState, { closeExistingWindows: true });\n     * // ... the window will revert to previous state, with just two views\n     *\n     * ```\n     */\n    async applySnapshot(requestedSnapshot, options) {\n        this.wire.sendAction('platform-apply-snapshot', this.identity).catch((e) => {\n            // don't expose\n        });\n        const errMsg = 'Requested snapshot must be a valid Snapshot object, or a url or filepath to such an object.';\n        let snapshot;\n        if (typeof requestedSnapshot === 'string') {\n            // Fetch and parse snapshot\n            try {\n                const response = await this._channel.wire.sendAction('get-application-manifest', {\n                    manifestUrl: requestedSnapshot\n                });\n                snapshot = response.payload.data;\n            }\n            catch (err) {\n                throw new Error(`${errMsg}: ${err}`);\n            }\n        }\n        else {\n            snapshot = requestedSnapshot;\n        }\n        if (!snapshot.windows) {\n            throw new Error(errMsg);\n        }\n        const client = await this.getClient();\n        await client.dispatch('apply-snapshot', {\n            snapshot,\n            options\n        });\n        return this;\n    }\n    /**\n     * Fetches a JSON manifest using the browser process and returns a Javascript object.\n     * Can be overwritten using {@link Platform.PlatformModule.init Platform.init}.\n     * @param manifestUrl The URL of the manifest to fetch.\n     *\n     * @remarks Can be overwritten using {@link Platform#init Platform.init}.\n     *\n     * @example\n     *\n     * ```js\n     * const platform = fin.Platform.getCurrentSync();\n     * const manifest = await platform.fetchManifest('https://www.path-to-manifest.com/app.json');\n     * console.log(manifest);\n     * ```\n     */\n    async fetchManifest(manifestUrl) {\n        const client = await this.getClient();\n        return client.dispatch('platform-fetch-manifest', { manifestUrl });\n    }\n    /**\n     * Retrieves a manifest by url and launches a legacy application manifest or snapshot into the platform.  Returns a promise that\n     * resolves to the wrapped Platform.\n     * @param manifestUrl - The URL of the manifest that will be launched into the platform.  If this app manifest\n     * contains a snapshot, that will be launched into the platform.  If not, the application described in startup_app options\n     * will be launched into the platform. The applicable startup_app options will become {@link OpenFin.ViewCreationOptions View Options}.\n     *\n     * @remarks If the app manifest contains a snapshot, that will be launched into the platform.  If not, the\n     * application described in startup_app options will be launched into the platform as a window with a single view.\n     * The applicable startup_app options will become View Options.\n     *\n     * @example\n     * ```js\n     * try {\n     *     const platform = fin.Platform.getCurrentSync();\n     *     await platform.launchContentManifest('http://localhost:5555/app.json');\n     *     console.log(`content launched successfully into platform`);\n     * } catch(e) {\n     *     console.error(e);\n     * }\n     * // For a local manifest file:\n     * try {\n     *     const platform = fin.Platform.getCurrentSync();\n     *     platform.launchContentManifest('file:///C:/somefolder/app.json');\n     *     console.log(`content launched successfully into platform`);\n     * } catch(e) {\n     *     console.error(e);\n     * }\n     * ```\n     * @experimental\n     */\n    async launchContentManifest(manifestUrl) {\n        this.wire.sendAction('platform-launch-content-manifest', this.identity).catch(() => {\n            // don't expose\n        });\n        const client = await this.getClient();\n        const manifest = await this.fetchManifest(manifestUrl);\n        client.dispatch('launch-into-platform', { manifest, manifestUrl });\n        return this;\n    }\n    /**\n     * Set the context of a host window. The context will be available to the window itself, and to its child Views. It will be saved in any platform snapshots.\n     * It can be retrieved using {@link Platform#getWindowContext getWindowContext}.\n     * @param context - A field where serializable context data can be stored to be saved in platform snapshots.\n     * @param target - A target window or view may optionally be provided. If no target is provided, the update will be applied\n     * to the current window (if called from a Window) or the current host window (if called from a View).\n     *\n     * @remarks The context data must be serializable.  This can only be called from a window or view that has been launched into a\n     * platform.\n     * This method can be called from the window itself, or from any child view. Context data is shared by all\n     * entities within a window.\n     *\n     * @example\n     * Setting own context:\n     * ```js\n     * const platform = fin.Platform.getCurrentSync();\n     * const contextData = {\n     *     security: 'STOCK',\n     *     currentView: 'detailed'\n     * }\n     *\n     * await platform.setWindowContext(contextData);\n     * // Context of current window is now set to `contextData`\n     * ```\n     *\n     * Setting the context of another window or view:\n     * ```js\n     * const platform = fin.Platform.getCurrentSync();\n     * const contextData = {\n     *     security: 'STOCK',\n     *     currentView: 'detailed'\n     * }\n     *\n     * const windowOrViewIdentity = { uuid: fin.me.uuid, name: 'nameOfWindowOrView' };\n     * await platform.setWindowContext(contextData, windowOrViewIdentity);\n     * // Context of the target window or view is now set to `contextData`\n     * ```\n     *\n     * A view can listen to changes to its host window's context by listening to the `host-context-changed` event.\n     * This event will fire when a host window's context is updated or when the view is reparented to a new window:\n     *\n     * ```js\n     * // From a view\n     * const contextChangeHandler = ({ context }) => {\n     *     console.log('Host window\\'s context has changed. New context data:', context);\n     *     // react to new context data here\n     * }\n     * await fin.me.on('host-context-changed', contextChangeHandler);\n     *\n     * const platform = await fin.Platform.getCurrentSync();\n     * const contextData = {\n     *     security: 'STOCK',\n     *     currentView: 'detailed'\n     * }\n     * platform.setWindowContext(contextData) // contextChangeHandler will log the new context\n     * ```\n     *\n     * To listen to a window's context updates, use the `context-changed` event:\n     * ```js\n     * // From a window\n     * const contextChangeHandler = ({ context }) => {\n     *     console.log('This window\\'s context has changed. New context data:', context);\n     *     // react to new context data here\n     * }\n     * await fin.me.on('context-changed', contextChangeHandler);\n     *\n     * const platform = await fin.Platform.getCurrentSync();\n     * const contextData = {\n     *     security: 'STOCK',\n     *     currentView: 'detailed'\n     * }\n     * platform.setWindowContext(contextData) // contextChangeHandler will log the new context\n     * ```\n     * @experimental\n     */\n    async setWindowContext(context = {}, target) {\n        this.wire.sendAction('platform-set-window-context', this.identity).catch((e) => {\n            // don't expose\n        });\n        if (!context) {\n            throw new Error('Please provide a serializable object or string to set the context.');\n        }\n        const client = await this.getClient();\n        const { entityType } = target ? await this.fin.System.getEntityInfo(target.uuid, target.name) : this.fin.me;\n        await client.dispatch('set-window-context', {\n            context,\n            entityType,\n            target: target || { uuid: this.fin.me.uuid, name: this.fin.me.name }\n        });\n    }\n    /**\n     * Get the context context of a host window that was previously set using {@link Platform#setWindowContext setWindowContext}.\n     * The context will be saved in any platform snapshots.  Returns a promise that resolves to the context.\n     * @param target - A target window or view may optionally be provided. If no target is provided, target will be\n     * the current window (if called from a Window) or the current host window (if called from a View).\n     *\n     * @remarks This method can be called from the window itself, or from any child view. Context data is shared\n     * by all entities within a window.\n     *\n     * @example\n     *\n     * Retrieving context from current window:\n     * ```js\n     * const platform = fin.Platform.getCurrentSync();\n     * const customContext = { answer: 42 };\n     * await platform.setWindowContext(customContext);\n     *\n     * const myContext = await platform.getWindowContext();\n     * console.log(myContext); // { answer: 42 }\n     * ```\n     *\n     * Retrieving the context of another window or view:\n     * ```js\n     * const platform = fin.Platform.getCurrentSync();\n     *\n     * const windowOrViewIdentity = { uuid: fin.me.uuid, name: 'nameOfWindowOrView' };\n     *\n     * const targetWindowContext = await platform.getWindowContext(windowOrViewIdentity);\n     * console.log(targetWindowContext); // context of target window\n     * ```\n     * @experimental\n     */\n    async getWindowContext(target) {\n        this.wire.sendAction('platform-get-window-context', this.identity).catch((e) => {\n            // don't expose\n        });\n        const client = await this.getClient();\n        const { entityType } = target ? await this.fin.System.getEntityInfo(target.uuid, target.name) : this.fin.me;\n        return client.dispatch('get-window-context', {\n            target: target || { uuid: this.fin.me.uuid, name: this.fin.me.name },\n            entityType\n        });\n    }\n    /**\n     * Closes a window. If enableBeforeUnload is enabled in the Platform options, any beforeunload handler set on Views will fire\n     * This behavior can be disabled by setting skipBeforeUnload to false in the options parameter.\n     * @param winId\n     * @param options\n     *\n     * @remarks This method works by setting a `close-requested` handler on the Platform Window. If you have your own `close-requested` handler set on the Platform Window as well,\n     * it is recommended to move that logic over to the [PlatformProvider.closeWindow]{@link PlatformProvider#closeWindow} override to ensure it runs when the Window closes.\n     *\n     * @example\n     *\n     * ```js\n     * // Close the current Window inside a Window context\n     * const platform = await fin.Platform.getCurrent();\n     * platform.closeWindow(fin.me.identity);\n     *\n     * // Close the Window from inside a View context\n     * const platform = await fin.Platform.getCurrent();\n     * const parentWindow = await fin.me.getCurrentWindow();\n     * platform.closeWindow(parentWindow.identity);\n     *\n     * // Close the Window and do not fire the before unload handler on Views\n     * const platform = await fin.Platform.getCurrent();\n     * platform.closeWindow(fin.me.identity, { skipBeforeUnload: true });\n     * ```\n     * @experimental\n     */\n    async closeWindow(windowId, options = { skipBeforeUnload: false }) {\n        this.wire.sendAction('platform-close-window', this.identity).catch((e) => {\n            // don't expose\n        });\n        const client = await this.getClient();\n        return client.dispatch('close-window', { windowId, options });\n    }\n}\nInstance$2.Platform = Platform;\n_Platform_connectToProvider = new WeakMap();\n\nvar layout = {};\n\nvar Factory$2 = {};\n\nvar Instance$1 = {};\n\nvar commonUtils = {};\n\nObject.defineProperty(commonUtils, \"__esModule\", { value: true });\ncommonUtils.overrideFromComposables = commonUtils.isValidPresetType = void 0;\nfunction isValidPresetType(type) {\n    switch (type) {\n        case 'columns':\n        case 'grid':\n        case 'rows':\n        case 'tabs':\n            return true;\n        default:\n            return false;\n    }\n}\ncommonUtils.isValidPresetType = isValidPresetType;\nfunction overrideFromComposables(...overrides) {\n    return (base) => overrides.reduceRight((p, c) => (b) => c(p(b)), (x) => x)(base);\n}\ncommonUtils.overrideFromComposables = overrideFromComposables;\ncommonUtils.default = { isValidPresetType };\n\nvar __classPrivateFieldGet$4 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar _Layout_layoutClient;\nObject.defineProperty(Instance$1, \"__esModule\", { value: true });\nInstance$1.Layout = void 0;\nconst lazy_1 = lazy;\nconst validate_1 = validate;\nconst base_1$5 = base;\nconst common_utils_1 = commonUtils;\nconst layout_entities_1 = layoutEntities;\nconst layout_constants_1$1 = layout_constants;\n/**\n *\n * Layouts give app providers the ability to embed multiple views in a single window. The Layout namespace\n * enables the initialization and manipulation of a window's Layout. A Layout will\n * emit events locally on the DOM element representing the layout-container.\n *\n *\n * ### Layout.DOMEvents\n *\n * When a Layout is created, it emits events onto the DOM element representing the Layout container.\n * This Layout container is the DOM element referenced by containerId in {@link Layout.LayoutModule#init Layout.init}.\n * You can use the built-in event emitter to listen to these events using [addEventListener](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener).\n * The events are emitted synchronously and only in the process where the Layout exists.\n * Any values returned by the called listeners are ignored and will be discarded.\n * If the target DOM element is destroyed, any events that have been set up on that element will be destroyed.\n *\n * @remarks The built-in event emitter is not an OpenFin event emitter so it doesn't share propagation semantics.\n *\n * #### {@link https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener addEventListener(type, listener [, options]);}\n * Adds a listener to the end of the listeners array for the specified event.\n * @example\n * ```js\n * const myLayoutContainer = document.getElementById('layout-container');\n *\n * myLayoutContainer.addEventListener('tab-created', function(event) {\n *      const { tabSelector } = event.detail;\n *      const tabElement = document.getElementById(tabSelector);\n *      const existingColor = tabElement.style.backgroundColor;\n *      tabElement.style.backgroundColor = \"red\";\n *      setTimeout(() => {\n *          tabElement.style.backgroundColor = existingColor;\n *      }, 2000);\n * });\n * ```\n *\n * #### {@link https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/removeEventListener removeEventListener(type, listener [, options]);}\n * Adds a listener to the end of the listeners array for the specified event.\n * @example\n * ```js\n * const myLayoutContainer = document.getElementById('layout-container');\n *\n * const listener = function(event) {\n *     console.log(event.detail);\n *     console.log('container-created event fired once, removing listener');\n *     myLayoutContainer.removeEventListener('container-created', listener);\n * };\n *\n * myLayoutContainer.addEventListener('container-created', listener);\n * ```\n *\n * ### Supported event types are:\n *\n * * tab-created\n * * container-created\n * * layout-state-changed\n * * tab-closed\n * * tab-dropped\n *\n * ### Layout DOM Node Events\n *\n * #### tab-created\n * Generated when a tab is created.  As a user drags and drops tabs within window, new tabs are created.  A single view may have multiple tabs created and destroyed during its lifetime attached to a single window.\n * ```js\n * // The response has the following shape in event.detail:\n * {\n *     containerSelector: \"container-component_A\",\n *     name: \"component_A\",\n *     tabSelector: \"tab-component_A\",\n *     topic: \"openfin-DOM-event\",\n *     type: \"tab-created\",\n *     uuid: \"OpenFin POC\"\n * }\n * ```\n *\n * #### container-created\n * Generated when a container is created.  A single view will have only one container during its lifetime attached to a single window and the container's lifecycle is tied to the view.  To discover when the container is destroyed, please listen to view-detached event.\n * ```js\n * // The response has the following shape in event.detail:\n * {\n *     containerSelector: \"container-component_A\",\n *     name: \"component_A\",\n *     tabSelector: \"tab-component_A\",\n *     topic: \"openfin-DOM-event\",\n *     type: \"container-created\",\n *     uuid: \"OpenFin POC\"\n * }\n * ```\n *\n * ### layout-state-changed\n * Generated when the state of the layout changes in any way, such as a view added/removed/replaced. Note that this event can fire frequently as the underlying layout can change multiple components from all kinds of changes (resizing for example). Given this, it is recommended to debounce this event and then you can use the {@link Layout#getConfig Layout.getConfig} API to retrieve the most up-to-date state.\n * ```js\n * // The response has the following shape in event.detail\n * {\n *     containerSelector: \"container-component_A\",\n *     name: \"component_A\",\n *     tabSelector: \"tab-component_A\",\n *     topic: \"openfin-DOM-event\",\n *     type: \"layout-state-changed\",\n *     uuid: \"OpenFin POC\"\n * }\n * ```\n *\n * #### tab-closed\n * Generated when a tab is closed.\n * ```js\n * // The response has the following shape in event.detail:\n * {\n *     containerSelector: \"container-component_A\",\n *     name: \"component_A\",\n *     tabSelector: \"tab-component_A\",\n *     topic: \"openfin-DOM-event\",\n *     type: \"tab-closed\",\n *     uuid: \"OpenFin POC\",\n *     url: \"http://openfin.co\"   // The url of the view that was closed.\n * }\n * ```\n *\n * #### tab-dropped\n * Generated when a tab is dropped.\n * ```js\n * // The response has the following shape in event.detail:\n * {\n *     containerSelector: \"container-component_A\",\n *     name: \"component_A\",\n *     tabSelector: \"tab-component_A\",\n *     topic: \"openfin-DOM-event\",\n *     type: \"tab-dropped\",\n *     uuid: \"OpenFin POC\",\n *     url: \"http://openfin.co\"    // The url of the view linked to the dropped tab.\n * }\n * ```\n */\nclass Layout extends base_1$5.Base {\n    /**\n     * @internal\n     */\n    // eslint-disable-next-line no-shadow\n    constructor(identity, wire) {\n        super(wire);\n        /**\n         * @internal\n         * Lazily constructed {@link LayoutEntitiesClient} bound to this platform's client and identity\n         * The client is for {@link LayoutEntitiesController}\n         */\n        _Layout_layoutClient.set(this, new lazy_1.Lazy(async () => layout_entities_1.LayoutNode.newLayoutEntitiesClient(await this.platform.getClient(), layout_constants_1$1.LAYOUT_CONTROLLER_ID, this.identity)));\n        /**\n         * Replaces a Platform window's layout with a new layout.\n         *\n         * @remarks Any views that were in the old layout but not the new layout will be destroyed. Views will be assigned a randomly generated name to avoid collisions.\n         * @example\n         * ```js\n         * let windowIdentity;\n         * if (fin.me.isWindow) {\n         *     windowIdentity = fin.me.identity;\n         * } else if (fin.me.isView) {\n         *     windowIdentity = (await fin.me.getCurrentWindow()).identity;\n         * } else {\n         *     throw new Error('Not running in a platform View or Window');\n         * }\n         *\n         * const layout = fin.Platform.Layout.wrapSync(windowIdentity);\n         *\n         * const newLayout = {\n         *     content: [\n         *         {\n         *             type: 'stack',\n         *             content: [\n         *                 {\n         *                     type: 'component',\n         *                     componentName: 'view',\n         *                     componentState: {\n         *                         name: 'new_component_A1',\n         *                         processAffinity: 'ps_1',\n         *                         url: 'https://www.example.com'\n         *                     }\n         *                 },\n         *                 {\n         *                     type: 'component',\n         *                     componentName: 'view',\n         *                     componentState: {\n         *                         name: 'new_component_A2',\n         *                         url: 'https://cdn.openfin.co/embed-web/chart.html'\n         *                     }\n         *                 }\n         *             ]\n         *         }\n         *     ]\n         * };\n         *\n         * layout.replace(newLayout);\n         * ```\n         */\n        this.replace = async (layout) => {\n            this.wire.sendAction('layout-replace').catch((e) => {\n                // don't expose\n            });\n            const client = await this.platform.getClient();\n            await client.dispatch('replace-layout', {\n                target: this.identity,\n                opts: { layout }\n            });\n        };\n        /**\n         * Replaces the specified view with a view with the provided configuration.\n         *\n         * @remarks The old view is stripped of its listeners and either closed or attached to the provider window\n         * depending on `detachOnClose` view option.\n         *\n         * @param viewToReplace Identity of the view to be replaced\n         * @param newView Creation options of the new view.\n         *\n         * @example\n         * ```js\n         * let currentWindow;\n         * if (fin.me.isWindow) {\n         *     currentWindow = fin.me;\n         * } else if (fin.me.isView) {\n         *     currentWindow = await fin.me.getCurrentWindow();\n         * } else {\n         *     throw new Error('Not running in a platform View or Window');\n         * }\n         *\n         * const layout = fin.Platform.Layout.wrapSync(currentWindow.identity);\n         * const viewToReplace = (await currentWindow.getCurrentViews())[0];\n         * const newViewConfig = {url: 'https://example.com'};\n         * await layout.replaceView(viewToReplace.identity, newViewConfig);\n         * ```\n         */\n        this.replaceView = async (viewToReplace, newView) => {\n            this.wire.sendAction('layout-replace-view').catch((e) => {\n                // don't expose\n            });\n            const client = await this.platform.getClient();\n            await client.dispatch('replace-view', {\n                target: this.identity,\n                opts: { viewToReplace, newView }\n            });\n        };\n        /**\n         * Replaces a Platform window's layout with a preset layout arrangement using the existing Views attached to the window.\n         * The preset options are `columns`, `grid`, `rows`, and `tabs`.\n         * @param options Mandatory object with `presetType` property that sets which preset layout arrangement to use.\n         * The preset options are `columns`, `grid`, `rows`, and `tabs`.\n         *\n         * @example\n         * ```js\n         * let windowIdentity;\n         * if (fin.me.isWindow) {\n         *     windowIdentity = fin.me.identity;\n         * } else if (fin.me.isView) {\n         *     windowIdentity = (await fin.me.getCurrentWindow()).identity;\n         * } else {\n         *     throw new Error('Not running in a platform View or Window');\n         * }\n         *\n         * const layout = fin.Platform.Layout.wrapSync(windowIdentity);\n         * await layout.applyPreset({ presetType: 'grid' });\n         *\n         * // wait 5 seconds until you change the layout from grid to tabs\n         * await new Promise (res => setTimeout(res, 5000));\n         * await layout.applyPreset({ presetType: 'tabs' });\n         * ```\n         */\n        this.applyPreset = async (options) => {\n            this.wire.sendAction('layout-apply-preset').catch((e) => {\n                // don't expose\n            });\n            const client = await this.platform.getClient();\n            const { presetType } = options;\n            if (!presetType || !(0, common_utils_1.isValidPresetType)(presetType)) {\n                throw new Error('Cannot apply preset layout, please include an applicable presetType property in the PresetLayoutOptions.');\n            }\n            await client.dispatch('apply-preset-layout', {\n                target: this.identity,\n                opts: { presetType }\n            });\n        };\n        const errorMsg = (0, validate_1.validateIdentity)(identity);\n        if (errorMsg) {\n            throw new Error(errorMsg);\n        }\n        this.identity = identity;\n        this.platform = this.fin.Platform.wrapSync({ uuid: identity.uuid });\n        if (identity.uuid === this.fin.me.uuid && identity.name === this.fin.me.name) {\n            this.init = this.fin.Platform.Layout.init;\n        }\n    }\n    /**\n     * Returns the configuration of the window's layout.  Returns the same information that is returned for all windows in getSnapshot.\n     *\n     * @remarks Cannot be called from a View.\n     *\n     *\n     * @example\n     * ```js\n     * const layout = fin.Platform.Layout.getCurrentSync();\n     * // Use wrapped instance to get the layout configuration of the current window's Layout:\n     * const layoutConfig = await layout.getConfig();\n     * ```\n     */\n    async getConfig() {\n        this.wire.sendAction('layout-get-config').catch((e) => {\n            // don't expose\n        });\n        const client = await this.platform.getClient();\n        return client.dispatch('get-frame-snapshot', {\n            target: this.identity\n        });\n    }\n    /**\n     * Retrieves the attached views in current window layout.\n     *\n     * @example\n     * ```js\n     * const layout = fin.Platform.Layout.getCurrentSync();\n     * const views = await layout.getCurrentViews();\n     * ```\n     */\n    async getCurrentViews() {\n        this.wire.sendAction('layout-get-views').catch((e) => {\n            // don't expose\n        });\n        const client = await this.platform.getClient();\n        const viewIdentities = await client.dispatch('get-layout-views', {\n            target: this.identity\n        });\n        return viewIdentities.map((identity) => this.fin.View.wrapSync(identity));\n    }\n    /**\n     * Retrieves the top level content item of the layout.\n     *\n     * @remarks Cannot be called from a view.\n     *\n     *\n     *\n     * @example\n     * ```js\n     * if (!fin.me.isWindow) {\n     *     throw new Error('Not running in a platform View.');\n     * }\n     *\n     * // From the layout window\n     * const layout = fin.Platform.Layout.getCurrentSync();\n     * // Retrieves the ColumnOrRow instance\n     * const rootItem = await layout.getRootItem();\n     * const content = await rootItem.getContent();\n     * console.log(`The root ColumnOrRow instance has ${content.length} item(s)`);\n     * ```\n     */\n    async getRootItem() {\n        this.wire.sendAction('layout-get-root-item').catch(() => {\n            // don't expose\n        });\n        const client = await __classPrivateFieldGet$4(this, _Layout_layoutClient, \"f\").getValue();\n        const root = await client.getRoot('layoutName' in this.identity ? this.identity : undefined);\n        return layout_entities_1.LayoutNode.getEntity(root, client);\n    }\n}\nInstance$1.Layout = Layout;\n_Layout_layoutClient = new WeakMap();\n\nvar __classPrivateFieldGet$3 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar __classPrivateFieldSet$3 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar _LayoutModule_instances, _LayoutModule_layoutInitializationAttempted, _LayoutModule_layoutManager, _LayoutModule_getLayoutManagerSpy, _LayoutModule_getSafeLayoutManager;\nObject.defineProperty(Factory$2, \"__esModule\", { value: true });\nFactory$2.LayoutModule = void 0;\nconst base_1$4 = base;\nconst Instance_1$2 = Instance$1;\nconst layout_constants_1 = layout_constants;\n/**\n * Static namespace for OpenFin API methods that interact with the {@link Layout} class, available under `fin.Platform.Layout`.\n */\nclass LayoutModule extends base_1$4.Base {\n    constructor() {\n        super(...arguments);\n        _LayoutModule_instances.add(this);\n        _LayoutModule_layoutInitializationAttempted.set(this, false);\n        _LayoutModule_layoutManager.set(this, null);\n        /**\n         * Initialize the window's Layout.\n         *\n         * @remarks Must be called from a custom window that has a 'layout' option set upon creation of that window.\n         * If a containerId is not provided, this method attempts to find an element with the id `layout-container`.\n         * A Layout will emit events locally on the DOM element representing the layout-container.\n         * In order to capture the relevant events during Layout initiation, set up the listeners on the DOM element prior to calling `init`.\n         * @param options - Layout init options.\n         *\n         * @experimental\n         *\n         * @example\n         * ```js\n         * // If no options are included, the layout in the window options is initialized in an element with the id `layout-container`\n         * const layout = await fin.Platform.Layout.init();\n         * ```\n         * <br>\n         *\n         * ```js\n         * const containerId = 'my-custom-container-id';\n         *\n         * const myLayoutContainer = document.getElementById(containerId);\n         *\n         * myLayoutContainer.addEventListener('tab-created', function(event) {\n         *     const { tabSelector } = event.detail;\n         *     const tabElement = document.getElementById(tabSelector);\n         *     const existingColor = tabElement.style.backgroundColor;\n         *     tabElement.style.backgroundColor = \"red\";\n         *     setTimeout(() => {\n         *         tabElement.style.backgroundColor = existingColor;\n         *     }, 2000);\n         * });\n         *\n         * // initialize the layout into an existing HTML element with the div `my-custom-container-id`\n         * // the window must have been created with a layout in its window options\n         * const layout = await fin.Platform.Layout.init({ containerId });\n         * ```\n         */\n        this.init = async (options = {}) => {\n            this.wire.sendAction('layout-init').catch((e) => {\n                // don't expose\n            });\n            if (!this.wire.environment.layoutAllowedInContext(this.fin)) {\n                throw new Error('Layout.init can only be called from a Window context.');\n            }\n            if (__classPrivateFieldGet$3(this, _LayoutModule_layoutInitializationAttempted, \"f\")) {\n                throw new Error('Layout.init was already called, please use Layout.create to add additional layouts.');\n            }\n            if (this.wire.environment.type === 'openfin') {\n                // preload the client\n                await this.fin.Platform.getCurrentSync().getClient();\n            }\n            __classPrivateFieldSet$3(this, _LayoutModule_layoutInitializationAttempted, true, \"f\");\n            // TODO: rename to createLayoutManager\n            __classPrivateFieldSet$3(this, _LayoutModule_layoutManager, await this.wire.environment.initLayoutManager(this.fin, this.wire, options), \"f\");\n            await this.wire.environment.applyLayoutSnapshot(this.fin, __classPrivateFieldGet$3(this, _LayoutModule_layoutManager, \"f\"), options);\n            const meIdentity = { name: this.fin.me.name, uuid: this.fin.me.uuid };\n            if (!options.layoutManagerOverride) {\n                // CORE-1081 to be removed when we actually delete the `layoutManager` prop\n                // in single-layout case, we return the undocumented layoutManager type\n                const layoutIdentity = { layoutName: layout_constants_1.DEFAULT_LAYOUT_KEY, ...meIdentity };\n                return __classPrivateFieldGet$3(this, _LayoutModule_getLayoutManagerSpy, \"f\").call(this, layoutIdentity);\n            }\n            return this.wrapSync(meIdentity);\n        };\n        _LayoutModule_getLayoutManagerSpy.set(this, (layoutIdentity) => {\n            const msg = '[Layout] You are using a deprecated property `layoutManager` - it will throw if you access it starting in v37.';\n            const managerProxy = new Proxy({}, {\n                get(target, key) {\n                    console.warn(`[Layout-mgr-proxy] accessing ${key.toString()}`);\n                    throw new Error(msg);\n                }\n            });\n            const layout = Object.assign(this.wrapSync(layoutIdentity), { layoutManager: managerProxy });\n            const layoutProxy = new Proxy(layout, {\n                get(target, key) {\n                    if (key === 'layoutManager') {\n                        console.warn(`[Layout-proxy] accessing ${key.toString()}`);\n                        throw new Error(msg);\n                    }\n                    return target[key];\n                }\n            });\n            return layoutProxy;\n        });\n        /**\n         * Returns the layout manager for the current window\n         * @returns\n         */\n        this.getCurrentLayoutManagerSync = () => {\n            return __classPrivateFieldGet$3(this, _LayoutModule_instances, \"m\", _LayoutModule_getSafeLayoutManager).call(this, `fin.Platform.Layout.getCurrentLayoutManagerSync()`);\n        };\n        this.create = async (options) => {\n            return this.wire.environment.createLayout(__classPrivateFieldGet$3(this, _LayoutModule_instances, \"m\", _LayoutModule_getSafeLayoutManager).call(this, `fin.Platform.Layout.create()`), options);\n        };\n        this.destroy = async (layoutIdentity) => {\n            return this.wire.environment.destroyLayout(__classPrivateFieldGet$3(this, _LayoutModule_instances, \"m\", _LayoutModule_getSafeLayoutManager).call(this, `fin.Platform.Layout.destroy()`), layoutIdentity);\n        };\n    }\n    /**\n     * Asynchronously returns a Layout object that represents a Window's layout.\n     *\n     * @example\n     * ```js\n     * let windowIdentity;\n     * if (!fin.me.isWindow) {\n     *     windowIdentity = fin.me.identity;\n     * } else if (fin.me.isView) {\n     *     windowIdentity = (await fin.me.getCurrentWindow()).identity;\n     * } else {\n     *     throw new Error('Not running in a platform View or Window');\n     * }\n     *\n     * const layout = await fin.Platform.Layout.wrap(windowIdentity);\n     * // Use wrapped instance to control layout, e.g.:\n     * const layoutConfig = await layout.getConfig();\n     * ```\n     */\n    async wrap(identity) {\n        this.wire.sendAction('layout-wrap').catch((e) => {\n            // don't expose\n        });\n        return new Instance_1$2.Layout(identity, this.wire);\n    }\n    /**\n     * Synchronously returns a Layout object that represents a Window's layout.\n     *\n     * @example\n     * ```js\n     * let windowIdentity;\n     * if (!fin.me.isWindow) {\n     *     windowIdentity = fin.me.identity;\n     * } else if (fin.me.isView) {\n     *     windowIdentity = (await fin.me.getCurrentWindow()).identity;\n     * } else {\n     *     throw new Error('Not running in a platform View or Window');\n     * }\n     *\n     * const layout = fin.Platform.Layout.wrapSync(windowIdentity);\n     * // Use wrapped instance to control layout, e.g.:\n     * const layoutConfig = await layout.getConfig();\n     * ```\n     */\n    wrapSync(identity) {\n        this.wire.sendAction('layout-wrap-sync').catch((e) => {\n            // don't expose\n        });\n        return new Instance_1$2.Layout(identity, this.wire);\n    }\n    /**\n     * Asynchronously returns a Layout object that represents a Window's layout.\n     *\n     * @example\n     * ```js\n     * const layout = await fin.Platform.Layout.getCurrent();\n     * // Use wrapped instance to control layout, e.g.:\n     * const layoutConfig = await layout.getConfig();\n     * ```\n     */\n    async getCurrent() {\n        this.wire.sendAction('layout-get-current').catch((e) => {\n            // don't expose\n        });\n        if (!this.fin.me.isWindow) {\n            throw new Error('You are not in a Window context.  Only Windows can have a Layout.');\n        }\n        const { uuid, name } = this.fin.me;\n        return this.wrap({ uuid, name });\n    }\n    /**\n     * Synchronously returns a Layout object that represents a Window's layout.\n     *\n     * @remarks Cannot be called from a view.\n     *\n     *\n     * @example\n     * ```js\n     * const layout = fin.Platform.Layout.getCurrentSync();\n     * // Use wrapped instance to control layout, e.g.:\n     * const layoutConfig = await layout.getConfig();\n     * ```\n     */\n    getCurrentSync() {\n        this.wire.sendAction('layout-get-current-sync').catch((e) => {\n            // don't expose\n        });\n        if (!this.fin.me.isWindow) {\n            throw new Error('You are not in a Window context.  Only Windows can have a Layout.');\n        }\n        const { uuid, name } = this.fin.me;\n        return this.wrapSync({ uuid, name });\n    }\n}\nFactory$2.LayoutModule = LayoutModule;\n_LayoutModule_layoutInitializationAttempted = new WeakMap(), _LayoutModule_layoutManager = new WeakMap(), _LayoutModule_getLayoutManagerSpy = new WeakMap(), _LayoutModule_instances = new WeakSet(), _LayoutModule_getSafeLayoutManager = function _LayoutModule_getSafeLayoutManager(method) {\n    if (!__classPrivateFieldGet$3(this, _LayoutModule_layoutManager, \"f\")) {\n        throw new Error(`You must call init before using the API ${method}`);\n    }\n    return __classPrivateFieldGet$3(this, _LayoutModule_layoutManager, \"f\");\n};\n\n(function (exports) {\n\t/**\n\t * Entry point for the OpenFin `Layout` subset of the `Platform` API (`fin.Platform.Layout`).\n\t *\n\t * * {@link LayoutModule} contains static members of the `Layout` API, accessible through `fin.Platform.Layout`.\n\t * * {@link Layout} describes an instance of an OpenFin Layout, e.g. as returned by `fin.Platform.Layout.getCurrent`.\n\t *\n\t * These are separate code entities, and are documented separately. In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/32.114.76.10/index.html),\n\t * both of these were documented on the same page.\n\t *\n\t * @packageDocumentation\n\t *\n\t */\n\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t    }\n\t    Object.defineProperty(o, k2, desc);\n\t}) : (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    o[k2] = m[k];\n\t}));\n\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t};\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t__exportStar(Factory$2, exports);\n\t__exportStar(Instance$1, exports); \n} (layout));\n\nObject.defineProperty(Factory$3, \"__esModule\", { value: true });\nFactory$3.PlatformModule = void 0;\nconst base_1$3 = base;\nconst Instance_1$1 = Instance$2;\nconst index_1$1 = layout;\n/**\n * Static namespace for OpenFin API methods that interact with the {@link Platform} class, available under `fin.Platform`.\n */\nclass PlatformModule extends base_1$3.Base {\n    /**\n     * @internal\n     */\n    constructor(wire, channel) {\n        super(wire);\n        this._channel = channel;\n        /**\n         *\n         * @desc Layouts give app providers the ability to embed multiple views in a single window.  The Layout namespace\n         * enables the initialization and manipulation of a window's Layout.  A Layout will\n         * <a href=\"tutorial-Layout.DOMEvents.html\">emit events locally</a> on the DOM element representing the layout-container.\n         */\n        this.Layout = new index_1$1.LayoutModule(this.wire);\n    }\n    /**\n     * Initializes a Platform. Must be called from the Provider when using a custom provider.\n     * @param options - platform options including a callback function that can be used to extend or replace\n     * default Provider behavior.\n     *\n     * @remarks Must be called from the Provider when using a custom provider.\n     *\n     * @example\n     *\n     * ```js\n     * // From Provider context\n     * await fin.Platform.init();\n     * // Platform API is now hooked up and windows contained in the manifest snapshot are open.\n     * ```\n     *\n     * `Platform.init` accepts an options object that can contain a callback function which can be used to extend or\n     * replace default Provider behavior. As an argument, this function will receive the `Provider` class, which is\n     * used to handle Platform actions. The function must return an object with methods to handle Platform API actions.\n     * The recommended approach is to extend the `Provider` class, overriding the methods you wish to alter, and return an\n     * instance of your subclass:\n     *\n     * ```js\n     * const overrideCallback = async (PlatformProvider) => {\n     *     // Actions can be performed before initialization.\n     *     // e.g. we might authenticate a user, set up a Channel, etc before initializing the Platform.\n     *     const { manifestUrl } = await fin.Application.getCurrentSync().getInfo();\n     *\n     *     // Extend or replace default PlatformProvider behavior by extending the PlatformProvider class.\n     *     class MyOverride extends PlatformProvider {\n     *         // Default behavior can be changed by implementing methods with the same names as those used by the default PlatformProvider.\n     *         async getSnapshot() {\n     *             // Since we are extending the class, we can call `super` methods to access default behavior.\n     *             const snapshot = await super.getSnapshot();\n     *             // But we can modify return values.\n     *             return { ...snapshot, answer: 42, manifestUrl };\n     *         }\n     *         async replaceLayout({ opts, target }) {\n     *             // To disable an API method, overwrite with a noop function.\n     *             return;\n     *         }\n     *     }\n     *     // Return instance with methods to be consumed by Platform.\n     *     // The returned object must implement all methods of the PlatformProvider class.\n     *     // By extending the class, we can simply inherit methods we do not wish to alter.\n     *     return new MyOverride();\n     * };\n     *\n     * fin.Platform.init({overrideCallback});\n     * ```\n     * @experimental\n     */\n    async init(options) {\n        if (!fin.__internal_.isPlatform || fin.me.name !== fin.me.uuid) {\n            throw new Error('fin.Platform.init should only be called from a custom platform provider running in the main window of the application.');\n        }\n        return this.wire.environment.initPlatform(this.fin, options);\n    }\n    /**\n     * Asynchronously returns a Platform object that represents an existing platform.\n     *\n     * @example\n     * ```js\n     * const { identity } = fin.me;\n     * const platform = await fin.Platform.wrap(identity);\n     * // Use wrapped instance to control layout, e.g.:\n     * const snapshot = await platform.getSnapshot();\n     * ```\n     */\n    async wrap(identity) {\n        this.wire.sendAction('platform-wrap').catch((e) => {\n            // don't expose\n        });\n        return new Instance_1$1.Platform({ uuid: identity.uuid }, this._channel);\n    }\n    /**\n     * Synchronously returns a Platform object that represents an existing platform.\n     *\n     * @example\n     * ```js\n     * const { identity } = fin.me;\n     * const platform = fin.Platform.wrapSync(identity);\n     * // Use wrapped instance to control layout, e.g.:\n     * const snapshot = await platform.getSnapshot();\n     * ```\n     */\n    wrapSync(identity) {\n        this.wire.sendAction('platform-wrap-sync').catch((e) => {\n            // don't expose\n        });\n        return new Instance_1$1.Platform({ uuid: identity.uuid }, this._channel);\n    }\n    /**\n     * Asynchronously returns a Platform object that represents the current platform.\n     *\n     * @example\n     * ```js\n     * const platform = await fin.Platform.getCurrent();\n     * // Use wrapped instance to control layout, e.g.:\n     * const snapshot = await platform.getSnapshot();\n     * ```\n     */\n    async getCurrent() {\n        this.wire.sendAction('platform-get-current').catch((e) => {\n            // don't expose\n        });\n        return this.wrap({ uuid: this.wire.me.uuid });\n    }\n    /**\n     * Synchronously returns a Platform object that represents the current platform.\n     *\n     * @example\n     * ```js\n     * const platform = fin.Platform.getCurrentSync();\n     * // Use wrapped instance to control layout, e.g.:\n     * const snapshot = await platform.getSnapshot();\n     * ```\n     */\n    getCurrentSync() {\n        this.wire.sendAction('platform-get-current-sync').catch((e) => {\n            // don't expose\n        });\n        return this.wrapSync({ uuid: this.wire.me.uuid });\n    }\n    /**\n     * Creates and starts a Platform and returns a wrapped and running Platform instance. The wrapped Platform methods can\n     * be used to launch content into the platform.  Promise will reject if the platform is already running.\n     *\n     * @example\n     * ```js\n     * try {\n     *     const platform = await fin.Platform.start({\n     *         uuid: 'platform-1',\n     *         autoShow: false,\n     *         defaultWindowOptions: {\n     *             stylesheetUrl: 'css-sheet-url',\n     *             cornerRounding: {\n     *                 height: 10,\n     *                 width: 10\n     *             }\n     *         }\n     *     });\n     *     console.log('Platform is running', platform);\n     * } catch(e) {\n     *     console.error(e);\n     * }\n     * ```\n     */\n    start(platformOptions) {\n        this.wire.sendAction('platform-start').catch((e) => {\n            // don't expose\n        });\n        // eslint-disable-next-line no-async-promise-executor\n        return new Promise(async (resolve, reject) => {\n            try {\n                const { uuid } = platformOptions;\n                // @ts-expect-error using private variable.\n                const app = await this.fin.Application._create({ ...platformOptions, isPlatformController: true });\n                // TODO: fix typing (internal)\n                // @ts-expect-error\n                app.once('platform-api-ready', () => resolve(this.wrapSync({ uuid })));\n                // @ts-expect-error using private variable.\n                app._run({ uuid });\n            }\n            catch (e) {\n                reject(e);\n            }\n        });\n    }\n    /**\n     * Retrieves platforms's manifest and returns a wrapped and running Platform.  If there is a snapshot in the manifest,\n     * it will be launched into the platform.\n     * @param manifestUrl - The URL of platform's manifest.\n     * @param opts - Parameters that the RVM will use.\n     *\n     * @example\n     * ```js\n     * try {\n     *     const platform = await fin.Platform.startFromManifest('https://openfin.github.io/golden-prototype/public.json');\n     *     console.log('Platform is running, wrapped platform: ', platform);\n     * } catch(e) {\n     *     console.error(e);\n     * }\n     * // For a local manifest file:\n     * try {\n     *     const platform = await fin.Platform.startFromManifest('file:///C:/somefolder/app.json');\n     *     console.log('Platform is running, wrapped platform: ', platform);\n     * } catch(e) {\n     *     console.error(e);\n     * }\n     * ```\n     */\n    startFromManifest(manifestUrl, opts) {\n        this.wire.sendAction('platform-start-from-manifest').catch((e) => {\n            // don't expose\n        });\n        // eslint-disable-next-line no-async-promise-executor\n        return new Promise(async (resolve, reject) => {\n            try {\n                // @ts-expect-error using private variable.\n                const app = await this.fin.Application._createFromManifest(manifestUrl);\n                // TODO: fix typing (internal)\n                // @ts-expect-error\n                app.once('platform-api-ready', () => resolve(this.wrapSync({ uuid: app.identity.uuid })));\n                // @ts-expect-error using private method without warning.\n                app._run(opts);\n            }\n            catch (e) {\n                reject(e);\n            }\n        });\n    }\n}\nFactory$3.PlatformModule = PlatformModule;\n\n(function (exports) {\n\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t    }\n\t    Object.defineProperty(o, k2, desc);\n\t}) : (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    o[k2] = m[k];\n\t}));\n\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t};\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t/**\n\t * Entry points for the OpenFin `Platform` API (`fin.Platform`)\n\t *\n\t * * {@link PlatformModule} contains static members of the `Platform` API, accessible through `fin.Platform`.\n\t * * {@link Platform} describes an instance of an OpenFin Platform, e.g. as returned by `fin.Platform.getCurrent`.\n\t *\n\t * These are separate code entities, and are documented separately.  In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/32.114.76.10/index.html),\n\t * both of these were documented on the same page.\n\t *\n\t * @packageDocumentation\n\t */\n\t__exportStar(Factory$3, exports);\n\t__exportStar(Instance$2, exports); \n} (platform));\n\nvar me = {};\n\n(function (exports) {\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\texports.getMe = exports.getBaseMe = exports.environmentUnsupportedMessage = void 0;\n\tconst view_1 = requireView();\n\tconst frame_1 = frame;\n\tconst window_1 = requireWindow();\n\tconst external_application_1 = externalApplication;\n\texports.environmentUnsupportedMessage = 'You are not running in OpenFin.';\n\tfunction getBaseMe(entityType, uuid, name) {\n\t    const entityTypeHelpers = {\n\t        isView: entityType === 'view',\n\t        isWindow: entityType === 'window',\n\t        isFrame: entityType === 'iframe',\n\t        isExternal: entityType === 'external connection'\n\t    };\n\t    return { ...entityTypeHelpers, uuid, name, entityType };\n\t}\n\texports.getBaseMe = getBaseMe;\n\t// We need to do a lot of casting as unknown here because the compiler get's confused about matching types. What matters is that it works on the outside\n\tfunction getMe(wire) {\n\t    const { uuid, name, entityType } = wire.me;\n\t    const unsupportedInterop = {\n\t        setContext() {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        addContextHandler() {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        getContextGroups() {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        joinContextGroup() {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        removeFromContextGroup() {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        getAllClientsInContextGroup() {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        getInfoForContextGroup() {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        }\n\t    };\n\t    const fallbackErrorMessage = 'Interop API has not been instantiated. Either connection has failed or you have not declared interop in your config.';\n\t    const fallbackInterop = {\n\t        setContext() {\n\t            throw new Error(fallbackErrorMessage);\n\t        },\n\t        addContextHandler() {\n\t            throw new Error(fallbackErrorMessage);\n\t        },\n\t        getContextGroups() {\n\t            throw new Error(fallbackErrorMessage);\n\t        },\n\t        joinContextGroup() {\n\t            throw new Error(fallbackErrorMessage);\n\t        },\n\t        removeFromContextGroup() {\n\t            throw new Error(fallbackErrorMessage);\n\t        },\n\t        getAllClientsInContextGroup() {\n\t            throw new Error(fallbackErrorMessage);\n\t        },\n\t        getInfoForContextGroup() {\n\t            throw new Error(fallbackErrorMessage);\n\t        }\n\t    };\n\t    const unsupportedEventBase = {\n\t        eventNames: () => {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        emit: () => {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        listeners: () => {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        listenerCount: () => {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        on: () => {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        addListener: () => {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        once: () => {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        prependListener: () => {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        prependOnceListener: () => {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        removeListener: () => {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        removeAllListeners: () => {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        }\n\t    };\n\t    switch (entityType) {\n\t        case 'view':\n\t            return Object.assign(new view_1.View(wire, { uuid, name }), getBaseMe(entityType, uuid, name), {\n\t                interop: fallbackInterop,\n\t                isOpenFin: true\n\t            });\n\t        case 'window':\n\t            return Object.assign(new window_1._Window(wire, { uuid, name }), getBaseMe(entityType, uuid, name), {\n\t                interop: fallbackInterop,\n\t                isOpenFin: true\n\t            });\n\t        case 'iframe':\n\t            return Object.assign(new frame_1._Frame(wire, { uuid, name }), getBaseMe(entityType, uuid, name), {\n\t                interop: fallbackInterop,\n\t                isOpenFin: true\n\t            });\n\t        case 'external connection':\n\t            return Object.assign(new external_application_1.ExternalApplication(wire, { uuid }), getBaseMe(entityType, uuid, name), {\n\t                interop: fallbackInterop,\n\t                isOpenFin: false\n\t            });\n\t        default:\n\t            return {\n\t                ...getBaseMe(entityType, uuid, name),\n\t                ...unsupportedEventBase,\n\t                interop: unsupportedInterop,\n\t                isOpenFin: false\n\t            };\n\t    }\n\t}\n\texports.getMe = getMe; \n} (me));\n\nvar interop = {};\n\nvar Factory$1 = {};\n\nvar inaccessibleObject = {};\n\nObject.defineProperty(inaccessibleObject, \"__esModule\", { value: true });\ninaccessibleObject.createWarningObject = inaccessibleObject.createUnusableObject = void 0;\nfunction createUnusableObject(message) {\n    const handle = () => {\n        throw new Error(message);\n    };\n    return new Proxy({}, {\n        apply: handle,\n        construct: handle,\n        defineProperty: handle,\n        deleteProperty: handle,\n        get: handle,\n        getOwnPropertyDescriptor: handle,\n        getPrototypeOf: handle,\n        has: handle,\n        isExtensible: handle,\n        ownKeys: handle,\n        preventExtensions: handle,\n        set: handle,\n        setPrototypeOf: handle\n    });\n}\ninaccessibleObject.createUnusableObject = createUnusableObject;\nfunction createWarningObject(message, obj) {\n    return new Proxy(obj, {\n        get: (...args) => {\n            // eslint-disable-next-line no-console\n            console.warn(message);\n            return Reflect.get(...args);\n        },\n        set: (...args) => {\n            // eslint-disable-next-line no-console\n            console.warn(message);\n            return Reflect.set(...args);\n        },\n        getOwnPropertyDescriptor: (...args) => {\n            // eslint-disable-next-line no-console\n            console.warn(message);\n            return Reflect.getOwnPropertyDescriptor(...args);\n        },\n        ownKeys: (...args) => {\n            // eslint-disable-next-line no-console\n            console.warn(message);\n            return Reflect.ownKeys(...args);\n        }\n    });\n}\ninaccessibleObject.createWarningObject = createWarningObject;\n\nvar InteropBroker = {};\n\nvar SessionContextGroupBroker = {};\n\nvar hasRequiredSessionContextGroupBroker;\n\nfunction requireSessionContextGroupBroker () {\n\tif (hasRequiredSessionContextGroupBroker) return SessionContextGroupBroker;\n\thasRequiredSessionContextGroupBroker = 1;\n\tObject.defineProperty(SessionContextGroupBroker, \"__esModule\", { value: true });\n\tconst _1 = requireInterop();\n\tlet SessionContextGroupBroker$1 = class SessionContextGroupBroker {\n\t    constructor(provider, id) {\n\t        this.provider = provider;\n\t        this.id = id;\n\t        this.lastContext = undefined;\n\t        this.contextGroupMap = new Map();\n\t        this.clients = new Map();\n\t        this.registerListeners();\n\t    }\n\t    registerListeners() {\n\t        this.provider.register(`sessionContextGroup:getContext-${this.id}`, this.getCurrentContext.bind(this));\n\t        this.provider.register(`sessionContextGroup:setContext-${this.id}`, this.setContext.bind(this));\n\t        this.provider.register(`sessionContextGroup:handlerAdded-${this.id}`, this.handlerAdded.bind(this));\n\t        this.provider.register(`sessionContextGroup:handlerRemoved-${this.id}`, this.handlerRemoved.bind(this));\n\t    }\n\t    getCurrentContext(payload) {\n\t        return payload.type ? this.contextGroupMap.get(payload.type) : this.lastContext;\n\t    }\n\t    setContext(payload, clientIdentity) {\n\t        const { context } = payload;\n\t        const contextIntegrityCheckResult = _1.InteropBroker.checkContextIntegrity(context);\n\t        if (contextIntegrityCheckResult.isValid === false) {\n\t            throw new Error(`Failed to set Context - bad Context. Reason: ${contextIntegrityCheckResult.reason}. Context: ${JSON.stringify(context)}`);\n\t        }\n\t        const clientState = this.getClientState(clientIdentity);\n\t        if (!clientState) {\n\t            // This shouldn't get hit.\n\t            throw new Error(`Client with Identity: ${clientIdentity.uuid} ${clientIdentity.name} not in Session Client State Map`);\n\t        }\n\t        // set the context\n\t        this.contextGroupMap.set(context.type, context);\n\t        this.lastContext = context;\n\t        const clientSubscriptionStates = Array.from(this.clients.values());\n\t        clientSubscriptionStates.forEach((client) => {\n\t            // eslint-disable-next-line no-unused-expressions\n\t            client.contextHandlers.get(context.type)?.forEach((handlerId) => {\n\t                this.provider.dispatch(client.clientIdentity, handlerId, context);\n\t            });\n\t            if (client.globalHandler) {\n\t                this.provider.dispatch(client.clientIdentity, client.globalHandler, context);\n\t            }\n\t        });\n\t    }\n\t    getClientState(id) {\n\t        return this.clients.get(id.endpointId);\n\t    }\n\t    async handlerAdded(payload, clientIdentity) {\n\t        const { handlerId, contextType } = payload;\n\t        const clientSubscriptionState = this.getClientState(clientIdentity);\n\t        if (!clientSubscriptionState) {\n\t            throw new Error(`Client with Identity: ${clientIdentity.uuid} ${clientIdentity.name} not in Client State Map`);\n\t        }\n\t        if (contextType) {\n\t            const currentHandlerList = clientSubscriptionState.contextHandlers.get(contextType) || [];\n\t            clientSubscriptionState.contextHandlers.set(contextType, [...currentHandlerList, handlerId]);\n\t            const currentContext = this.contextGroupMap.get(contextType);\n\t            if (currentContext) {\n\t                await this.provider.dispatch(clientIdentity, handlerId, currentContext);\n\t            }\n\t        }\n\t        else {\n\t            clientSubscriptionState.globalHandler = handlerId;\n\t            const globalDispatchPromises = [...this.contextGroupMap.keys()].map(async (currentContextType) => {\n\t                const currentContext = this.contextGroupMap.get(currentContextType);\n\t                if (currentContext) {\n\t                    await this.provider.dispatch(clientIdentity, handlerId, currentContext);\n\t                }\n\t            });\n\t            await Promise.all(globalDispatchPromises);\n\t        }\n\t    }\n\t    handlerRemoved(payload, clientIdentity) {\n\t        const { handlerId } = payload;\n\t        const client = this.clients.get(clientIdentity.endpointId);\n\t        if (client) {\n\t            Array.from(client.contextHandlers).forEach(([, handlers]) => {\n\t                const index = handlers.indexOf(handlerId);\n\t                if (index > -1) {\n\t                    handlers.splice(index, 1);\n\t                }\n\t            });\n\t            if (client.globalHandler === handlerId) {\n\t                client.globalHandler = undefined;\n\t            }\n\t        }\n\t        else {\n\t            console.warn(`Trying to remove a handler from a client that isn't mapped. handlerId: ${handlerId}. clientIdentity: ${clientIdentity}`);\n\t        }\n\t    }\n\t    registerNewClient(clientIdentity) {\n\t        if (!this.clients.has(clientIdentity.endpointId)) {\n\t            const clientSubscriptionState = {\n\t                contextHandlers: new Map(),\n\t                clientIdentity,\n\t                globalHandler: undefined\n\t            };\n\t            this.clients.set(clientIdentity.endpointId, clientSubscriptionState);\n\t        }\n\t    }\n\t    onDisconnection(clientIdentity) {\n\t        this.clients.delete(clientIdentity.endpointId);\n\t    }\n\t};\n\tSessionContextGroupBroker.default = SessionContextGroupBroker$1;\n\treturn SessionContextGroupBroker;\n}\n\nvar utils$3 = {};\n\n(function (exports) {\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\texports.wrapIntentHandler = exports.BROKER_ERRORS = exports.generateOverrideWarning = exports.generateOverrideError = exports.wrapContextHandler = exports.wrapInTryCatch = exports.generateId = void 0;\n\tconst generateId = () => `${Math.random()}${Date.now()}`;\n\texports.generateId = generateId;\n\tconst wrapInTryCatch = (f, prefix) => (...args) => {\n\t    try {\n\t        return f(...args);\n\t    }\n\t    catch (e) {\n\t        throw new Error((prefix || '') + e);\n\t    }\n\t};\n\texports.wrapInTryCatch = wrapInTryCatch;\n\tconst wrapContextHandler = (handler, handlerId) => {\n\t    return async (context) => {\n\t        try {\n\t            await handler(context);\n\t        }\n\t        catch (error) {\n\t            console.error(`Error thrown by handler ${handlerId} for context type ${context.type}: ${error}`);\n\t            throw error;\n\t        }\n\t    };\n\t};\n\texports.wrapContextHandler = wrapContextHandler;\n\tconst generateOverrideError = (clientApi, brokerApi) => {\n\t    return `You have tried to to use ${clientApi} but ${brokerApi} has not been overridden in the Interop Broker. Please override this function. Refer to our documentation for more info.`;\n\t};\n\texports.generateOverrideError = generateOverrideError;\n\tconst generateOverrideWarning = (fdc3ClientApi, brokerApi, identity, interopClientApi) => {\n\t    const { uuid, name } = identity;\n\t    const message = interopClientApi\n\t        ? `Entity with identity: ${uuid}/${name} has called ${interopClientApi} or ${fdc3ClientApi} but ${brokerApi} has not been overridden.`\n\t        : `Entity with identity: ${uuid}/${name} has called ${fdc3ClientApi} but ${brokerApi} has not been overridden.`;\n\t    return message;\n\t};\n\texports.generateOverrideWarning = generateOverrideWarning;\n\texports.BROKER_ERRORS = {\n\t    fireIntent: (0, exports.generateOverrideError)('fireIntent', 'handleFiredIntent'),\n\t    fireIntentForContext: (0, exports.generateOverrideError)('fireIntentForContext', 'handleFiredIntentForContext'),\n\t    getInfoForIntent: (0, exports.generateOverrideError)('getInfoForIntent', 'handleInfoForIntent'),\n\t    getInfoForIntentsByContext: (0, exports.generateOverrideError)('getInfoForIntentsByContext', 'handleInfoForIntentsByContext'),\n\t    joinSessionContextGroupWithJoinContextGroup: 'The Context Group you have tried to join is a Session Context Group. Custom Context Groups can only be defined by the Interop Broker through code or manifest configuration. Please use joinSessionContextGroup.',\n\t    fdc3Open: (0, exports.generateOverrideError)('fdc3.open', 'fdc3HandleOpen'),\n\t    fdc3FindInstances: (0, exports.generateOverrideError)('fdc3.findInstances', 'fdc3HandleFindInstances'),\n\t    fdc3GetAppMetadata: (0, exports.generateOverrideError)('fdc3.getAppMetadata', 'fdc3HandleGetAppMetadata'),\n\t    fdc3GetInfo: (0, exports.generateOverrideError)('fdc3.getInfo', 'fdc3HandleGetInfo')\n\t};\n\tconst wrapIntentHandler = (handler, handlerId) => {\n\t    return async (intent) => {\n\t        try {\n\t            return handler(intent);\n\t        }\n\t        catch (error) {\n\t            console.error(`Error thrown by handler ${handlerId}: ${error}`);\n\t            throw error;\n\t        }\n\t    };\n\t};\n\texports.wrapIntentHandler = wrapIntentHandler; \n} (utils$3));\n\nvar PrivateChannelProvider = {};\n\nvar hasRequiredPrivateChannelProvider;\n\nfunction requirePrivateChannelProvider () {\n\tif (hasRequiredPrivateChannelProvider) return PrivateChannelProvider;\n\thasRequiredPrivateChannelProvider = 1;\n\tObject.defineProperty(PrivateChannelProvider, \"__esModule\", { value: true });\n\tPrivateChannelProvider.PrivateChannelProvider = void 0;\n\tconst InteropBroker_1 = requireInteropBroker();\n\tlet PrivateChannelProvider$1 = class PrivateChannelProvider {\n\t    constructor(provider, id) {\n\t        this.provider = provider;\n\t        this.id = id;\n\t        this.clients = new Map();\n\t        this.registerListeners();\n\t        this.contextByContextType = new Map();\n\t        this.lastContext = undefined;\n\t        this.provider.onConnection((clientIdentity) => this.registerNewClient(clientIdentity));\n\t        this.provider.onDisconnection(async (clientIdentity) => {\n\t            const { endpointId } = clientIdentity;\n\t            if (this.clients.has(endpointId)) {\n\t                await this.handleClientDisconnecting(clientIdentity);\n\t            }\n\t            if ((await this.provider.getAllClientInfo()).length === 0) {\n\t                this.provider.destroy();\n\t            }\n\t        });\n\t    }\n\t    getClientState(id) {\n\t        return this.clients.get(id.endpointId);\n\t    }\n\t    registerListeners() {\n\t        this.provider.register('broadcast', this.broadcast.bind(this));\n\t        this.provider.register('getCurrentContext', this.getCurrentContext.bind(this));\n\t        this.provider.register('contextHandlerAdded', this.contextHandlerAdded.bind(this));\n\t        this.provider.register('contextHandlerRemoved', this.contextHandlerRemoved.bind(this));\n\t        this.provider.register('nonStandardHandlerRemoved', this.nonStandardHandlerRemoved.bind(this));\n\t        this.provider.register('onAddContextHandlerAdded', this.onAddContextHandlerAdded.bind(this));\n\t        this.provider.register('onDisconnectHandlerAdded', this.onDisconnectHandlerAdded.bind(this));\n\t        this.provider.register('onUnsubscribeHandlerAdded', this.onUnsubscribeHandlerAdded.bind(this));\n\t        this.provider.register('clientDisconnecting', (payload, clientIdentity) => {\n\t            this.handleClientDisconnecting(clientIdentity);\n\t        });\n\t    }\n\t    broadcast(payload, broadcasterClientIdentity) {\n\t        const { context } = payload;\n\t        const broadcasterClientState = this.getClientState(broadcasterClientIdentity);\n\t        if (!broadcasterClientState) {\n\t            throw new Error(`Client with Identity: ${broadcasterClientIdentity.uuid} ${broadcasterClientIdentity.name}, tried to call broadcast, is not connected to this Private Channel`);\n\t        }\n\t        const contextIntegrityCheckResult = InteropBroker_1.InteropBroker.checkContextIntegrity(context);\n\t        if (contextIntegrityCheckResult.isValid === false) {\n\t            throw new Error(`Failed to broadcast - bad Context. Reason: ${contextIntegrityCheckResult.reason}. Context: ${JSON.stringify(context)}`);\n\t        }\n\t        this.contextByContextType.set(context.type, context);\n\t        this.lastContext = context;\n\t        Array.from(this.clients.values()).forEach((currClientState) => {\n\t            const handlerIdsForContextType = currClientState.handlerIdsByContextTypes.get(context.type);\n\t            if (handlerIdsForContextType) {\n\t                handlerIdsForContextType.forEach((handlerId) => {\n\t                    this.provider.dispatch(currClientState.clientIdentity, handlerId, context);\n\t                });\n\t            }\n\t            if (currClientState.globalHandler) {\n\t                this.provider.dispatch(currClientState.clientIdentity, currClientState.globalHandler, context);\n\t            }\n\t        });\n\t    }\n\t    getCurrentContext(payload, senderClientIdentity) {\n\t        const { contextType } = payload;\n\t        const clientState = this.getClientState(senderClientIdentity);\n\t        if (!clientState) {\n\t            throw new Error(`Client with Identity: ${senderClientIdentity.uuid} ${senderClientIdentity.name}, tried to call getCurrentContext, is not connected to this Private Channel`);\n\t        }\n\t        if (contextType !== undefined) {\n\t            const currentContext = this.contextByContextType.get(contextType);\n\t            if (currentContext)\n\t                return currentContext;\n\t            return null;\n\t        }\n\t        return this.lastContext ? this.lastContext : null;\n\t    }\n\t    contextHandlerAdded(payload, senderClientIdentity) {\n\t        const { handlerId, contextType } = payload;\n\t        const senderClientState = this.getClientState(senderClientIdentity);\n\t        if (!senderClientState) {\n\t            throw new Error(`Client with Identity: ${senderClientIdentity.uuid} ${senderClientIdentity.name}, tried to call addContextListener, is not connected to this Private Channel`);\n\t        }\n\t        if (contextType) {\n\t            const currentHandlersList = senderClientState.handlerIdsByContextTypes.get(contextType) || [];\n\t            senderClientState.handlerIdsByContextTypes.set(contextType, [...currentHandlersList, handlerId]);\n\t        }\n\t        else {\n\t            senderClientState.globalHandler = handlerId;\n\t        }\n\t        Array.from(this.clients.values()).forEach((currClientState) => {\n\t            if (currClientState.clientIdentity.endpointId !== senderClientIdentity.endpointId &&\n\t                currClientState.onAddContextListenerHandlerId) {\n\t                this.provider.dispatch(currClientState.clientIdentity, currClientState.onAddContextListenerHandlerId, contextType);\n\t            }\n\t        });\n\t    }\n\t    async contextHandlerRemoved(payload, removingClientIdentity) {\n\t        // MC: Made this removal async to ensure that onUnsubscribe handlers are hit before anything else happens.\n\t        const { handlerId } = payload;\n\t        const removingClientState = this.getClientState(removingClientIdentity);\n\t        if (removingClientState) {\n\t            let contextType;\n\t            if (removingClientState.globalHandler === handlerId) {\n\t                removingClientState.globalHandler = undefined;\n\t            }\n\t            else {\n\t                for (const [currContextType, handlersIds] of removingClientState.handlerIdsByContextTypes) {\n\t                    const index = handlersIds.indexOf(handlerId);\n\t                    if (index > -1) {\n\t                        handlersIds.splice(index, 1);\n\t                        contextType = currContextType;\n\t                    }\n\t                }\n\t            }\n\t            // getting only valid client connections here, it is possible we haven't removed a disconnected client from the map yet\n\t            // so we need to ensure we don't dispatch to any disconnected client\n\t            // TODO: Take a look at our client disconnection logic and see if we can handle client disconnection cleanly\n\t            const clientsToDispatchTo = await this.getConnectedClients();\n\t            const dispatchPromises = clientsToDispatchTo.map(async (otherClientState) => {\n\t                const { clientIdentity, clientIdentity: { endpointId }, onUnsubscribeHandlerId } = otherClientState;\n\t                if (endpointId !== removingClientIdentity.endpointId && onUnsubscribeHandlerId) {\n\t                    await this.provider.dispatch(clientIdentity, onUnsubscribeHandlerId, contextType);\n\t                }\n\t            });\n\t            try {\n\t                await Promise.all(dispatchPromises);\n\t            }\n\t            catch (error) {\n\t                console.error(`Problem when attempting to dispatch to onUnsubscribeHandlers. Error: ${error} Removing Client: ${handlerId}. uuid: ${removingClientIdentity.uuid}. name: ${removingClientIdentity.name}. endpointId: ${removingClientIdentity.endpointId}`);\n\t                throw new Error(error);\n\t            }\n\t        }\n\t        else {\n\t            console.warn(`Trying to remove a handler from a client that isn't mapped. handlerId: ${handlerId}. uuid: ${removingClientIdentity.uuid}. name: ${removingClientIdentity.name}. endpointId: ${removingClientIdentity.endpointId}.`);\n\t        }\n\t    }\n\t    nonStandardHandlerRemoved(payload, id) {\n\t        const { handlerId } = payload;\n\t        const clientState = this.getClientState(id);\n\t        if (clientState) {\n\t            if (clientState.onDisconnectHandlerId === handlerId) {\n\t                clientState.onDisconnectHandlerId = undefined;\n\t            }\n\t            else if (clientState.onAddContextListenerHandlerId === handlerId) {\n\t                clientState.onAddContextListenerHandlerId = undefined;\n\t            }\n\t            else if (clientState.onUnsubscribeHandlerId === handlerId) {\n\t                clientState.onUnsubscribeHandlerId = undefined;\n\t            }\n\t        }\n\t        else {\n\t            console.warn(`Trying to remove a handler from a client that isn't mapped. handlerId: ${handlerId}. clientIdentity: ${id}`);\n\t        }\n\t    }\n\t    onAddContextHandlerAdded(payload, senderClientIdentity) {\n\t        const clientState = this.getClientState(senderClientIdentity);\n\t        const { handlerId } = payload;\n\t        if (!clientState) {\n\t            throw new Error(`Client with Identity: ${senderClientIdentity.uuid} ${senderClientIdentity.name}, tried to call onAddContextListener, is not connected to this Private Channel`);\n\t        }\n\t        clientState.onAddContextListenerHandlerId = handlerId;\n\t        // FDC3 Spec says that the added listener should fire for all previously-registered addContextListeners from the other client\n\t        Array.from(this.clients.values()).forEach((otherClientState) => {\n\t            if (otherClientState.clientIdentity.endpointId !== senderClientIdentity.endpointId) {\n\t                Array.from(otherClientState.handlerIdsByContextTypes.keys()).forEach((subscribedContextType) => {\n\t                    this.provider.dispatch(senderClientIdentity, handlerId, subscribedContextType);\n\t                });\n\t            }\n\t        });\n\t    }\n\t    onDisconnectHandlerAdded(payload, id) {\n\t        const clientState = this.getClientState(id);\n\t        const { handlerId } = payload;\n\t        if (!clientState) {\n\t            throw new Error(`Client with Identity: ${id.uuid} ${id.name}, tried to call onDisconnect, is not connected to this Private Channel`);\n\t        }\n\t        clientState.onDisconnectHandlerId = handlerId;\n\t    }\n\t    onUnsubscribeHandlerAdded(payload, id) {\n\t        const clientState = this.getClientState(id);\n\t        const { handlerId } = payload;\n\t        if (!clientState) {\n\t            throw new Error(`Client with Identity: ${id.uuid} ${id.name}, tried to call onUnsubscribe, is not connected to this Private Channel`);\n\t        }\n\t        clientState.onUnsubscribeHandlerId = handlerId;\n\t    }\n\t    removeClient(disconnectingClientIdentity) {\n\t        const disconnectingClientState = this.getClientState(disconnectingClientIdentity);\n\t        if (!disconnectingClientState) {\n\t            throw new Error(`Client with Identity: ${disconnectingClientIdentity.uuid} ${disconnectingClientIdentity.name}, tried to call disconnect, is not connected to this Private Channel`);\n\t        }\n\t        disconnectingClientState.handlerIdsByContextTypes.clear();\n\t        this.clients.delete(disconnectingClientIdentity.endpointId);\n\t    }\n\t    async fireOnDisconnectForOtherClients(disconnectingClientIdentity) {\n\t        // TODO: call onDisconnect Handler of the other client only.\n\t        // CURRENTLY, just calling the onDisconnect handler for all the other clients. Once we limit it to just one other client, we can eliminate all the iteration code.\n\t        const { endpointId } = disconnectingClientIdentity;\n\t        // getting only valid client connections here, it is possible we haven't removed a disconnected client from the map yet\n\t        // so we need to ensure we don't dispatch to any disconnected client\n\t        // TODO: Take a look at our client disconnection logic and see if we can handle client disconnection cleanly\n\t        const clientsToDispatchTo = await this.getConnectedClients();\n\t        const dispatchPromises = clientsToDispatchTo.map(async (otherClientState) => {\n\t            const { clientIdentity: { endpointId: otherClientEndpointId }, onDisconnectHandlerId } = otherClientState;\n\t            if (otherClientEndpointId !== endpointId && onDisconnectHandlerId) {\n\t                await this.provider.dispatch(otherClientState.clientIdentity, onDisconnectHandlerId);\n\t            }\n\t        });\n\t        try {\n\t            await Promise.all(dispatchPromises);\n\t        }\n\t        catch (error) {\n\t            console.error(`Problem when attempting to dispatch to onDisconnectHandlers. Error: ${error} Disconnecting Client: uuid: ${disconnectingClientIdentity.uuid}. name: ${disconnectingClientIdentity.name}. endpointId: ${disconnectingClientIdentity.endpointId}`);\n\t            throw new Error(error);\n\t        }\n\t    }\n\t    async unsubscribeAll(clientIdentity) {\n\t        const { endpointId } = clientIdentity;\n\t        const state = this.clients.get(endpointId);\n\t        if (state) {\n\t            const contextTypeHandlerIds = Array.from(state.handlerIdsByContextTypes.values()).flat();\n\t            const globalHandlerId = state.globalHandler;\n\t            if (contextTypeHandlerIds.length > 0) {\n\t                const unsubPromises = contextTypeHandlerIds.map(async (handlerId) => {\n\t                    return this.contextHandlerRemoved({ handlerId }, clientIdentity);\n\t                });\n\t                try {\n\t                    await Promise.all(unsubPromises);\n\t                }\n\t                catch (error) {\n\t                    console.error(error.message);\n\t                }\n\t            }\n\t            if (globalHandlerId) {\n\t                try {\n\t                    await this.contextHandlerRemoved({ handlerId: globalHandlerId }, clientIdentity);\n\t                }\n\t                catch (error) {\n\t                    console.error(error.message);\n\t                }\n\t            }\n\t        }\n\t    }\n\t    async handleClientDisconnecting(disconnectingClientIdentity) {\n\t        await this.unsubscribeAll(disconnectingClientIdentity);\n\t        this.removeClient(disconnectingClientIdentity);\n\t        await this.fireOnDisconnectForOtherClients(disconnectingClientIdentity);\n\t    }\n\t    registerNewClient(clientIdentity) {\n\t        if (!this.clients.has(clientIdentity.endpointId)) {\n\t            const clientSubscriptionState = {\n\t                clientIdentity,\n\t                handlerIdsByContextTypes: new Map(),\n\t                globalHandler: undefined,\n\t                onAddContextListenerHandlerId: undefined,\n\t                onUnsubscribeHandlerId: undefined,\n\t                onDisconnectHandlerId: undefined\n\t            };\n\t            this.clients.set(clientIdentity.endpointId, clientSubscriptionState);\n\t        }\n\t    }\n\t    async getConnectedClients() {\n\t        const allClientInfo = await this.provider.getAllClientInfo();\n\t        return Array.from(this.clients.values()).filter((clientState) => {\n\t            const { uuid, name } = clientState.clientIdentity;\n\t            return allClientInfo.some((clientInfo) => {\n\t                return name === clientInfo.name && uuid === clientInfo.uuid;\n\t            });\n\t        });\n\t    }\n\t    static init(channelProvider, id) {\n\t        return new PrivateChannelProvider(channelProvider, id);\n\t    }\n\t};\n\tPrivateChannelProvider.PrivateChannelProvider = PrivateChannelProvider$1;\n\treturn PrivateChannelProvider;\n}\n\nvar hasRequiredInteropBroker;\n\nfunction requireInteropBroker () {\n\tif (hasRequiredInteropBroker) return InteropBroker;\n\thasRequiredInteropBroker = 1;\n\tvar __classPrivateFieldSet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n\t    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n\t    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n\t    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n\t    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n\t};\n\tvar __classPrivateFieldGet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n\t    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n\t    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n\t    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n\t};\n\tvar __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {\n\t    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n\t};\n\tvar _InteropBroker_fdc3Info, _InteropBroker_contextGroups, _InteropBroker_providerPromise;\n\tObject.defineProperty(InteropBroker, \"__esModule\", { value: true });\n\tInteropBroker.InteropBroker = void 0;\n\tconst base_1 = base;\n\tconst SessionContextGroupBroker_1 = __importDefault(requireSessionContextGroupBroker());\n\tconst utils_1 = utils$3;\n\tconst isEqual_1 = __importDefault(require$$3);\n\tconst PrivateChannelProvider_1 = requirePrivateChannelProvider();\n\tconst lazy_1 = lazy;\n\tconst defaultContextGroups = [\n\t    {\n\t        id: 'green',\n\t        displayMetadata: {\n\t            color: '#00CC88',\n\t            name: 'green'\n\t        }\n\t    },\n\t    {\n\t        id: 'purple',\n\t        displayMetadata: {\n\t            color: '#8C61FF',\n\t            name: 'purple'\n\t        }\n\t    },\n\t    {\n\t        id: 'orange',\n\t        displayMetadata: {\n\t            color: '#FF8C4C',\n\t            name: 'orange'\n\t        }\n\t    },\n\t    {\n\t        id: 'red',\n\t        displayMetadata: {\n\t            color: '#FF5E60',\n\t            name: 'red'\n\t        }\n\t    },\n\t    {\n\t        id: 'pink',\n\t        displayMetadata: {\n\t            color: '#FF8FB8',\n\t            name: 'pink'\n\t        }\n\t    },\n\t    {\n\t        id: 'yellow',\n\t        displayMetadata: {\n\t            color: '#E9FF8F',\n\t            name: 'yellow'\n\t        }\n\t    }\n\t];\n\t/**\n\t * {@link https://developers.openfin.co/of-docs/docs/enable-color-linking}\n\t *\n\t * The Interop Broker is responsible for keeping track of the Interop state of the Platform, and for directing messages to the proper locations.\n\t *\n\t * @remarks This class contains some types related to FDC3 that are specific to OpenFin. {@link https://developers.openfin.co/of-docs/docs/fdc3-support-in-openfin OpenFin's FDC3 support} is forward- and backward-compatible.\n\t * Standard types for {@link https://fdc3.finos.org/ FDC3} do not appear in OpenFin’s API documentation, to avoid duplication.\n\t *\n\t * ---\n\t *\n\t * There are 2 ways to inject custom functionality into the Interop Broker:\n\t *\n\t * **1. Configuration**\n\t *\n\t * At the moment, you can configure the default context groups for the Interop Broker without having to override it. To do so, include the `interopBrokerConfiguration` `contextGroups` option in your `platform` options in your manifest. This is the preferred method.\n\t * ```js\n\t * {\n\t *      \"runtime\": {\n\t *          \"arguments\": \"--v=1 --inspect\",\n\t *          \"version\": \"alpha-v19\"\n\t *      },\n\t *      \"platform\": {\n\t *          \"uuid\": \"platform_customization_local\",\n\t *          \"applicationIcon\": \"https://openfin.github.io/golden-prototype/favicon.ico\",\n\t *          \"autoShow\": false,\n\t *          \"providerUrl\": \"http://localhost:5555/provider.html\",\n\t *          \"interopBrokerConfiguration\": {\n\t *              \"contextGroups\": [\n\t *                  {\n\t *                      \"id\": \"green\",\n\t *                      \"displayMetadata\": {\n\t *                          \"color\": \"#00CC88\",\n\t *                          \"name\": \"green\"\n\t *                      }\n\t *                  },\n\t *                  {\n\t *                      \"id\": \"purple\",\n\t *                      \"displayMetadata\": {\n\t *                          \"color\": \"#8C61FF\",\n\t *                          \"name\": \"purple\"\n\t *                      }\n\t *                  },\n\t *              ]\n\t *          }\n\t *      }\n\t * }\n\t * ```\n\t *\n\t * By default the Interop Broker logs all actions to the console. You can disable this by using the logging option in `interopBrokerConfiguration`:\n\t * ```js\n\t * {\n\t *      \"runtime\": {\n\t *          \"arguments\": \"--v=1 --inspect\",\n\t *          \"version\": \"alpha-v19\"\n\t *      },\n\t *      \"platform\": {\n\t *          \"uuid\": \"platform_customization_local\",\n\t *          \"applicationIcon\": \"https://openfin.github.io/golden-prototype/favicon.ico\",\n\t *          \"autoShow\": false,\n\t *          \"providerUrl\": \"http://localhost:5555/provider.html\",\n\t *\t\t    \"interopBrokerConfiguration\": {\n\t *       \t\t\"logging\": {\n\t *   \t\t\t\t\"beforeAction\": {\n\t *   \t\t\t\t\t\"enabled\": false\n\t *   \t\t\t\t},\n\t *   \t\t\t\t\"afterAction\": {\n\t *   \t\t\t\t\t\"enabled\": false\n\t *   \t\t\t\t}\n\t *   \t\t\t}\n\t *\t\t    }\n\t *      }\n\t * }\n\t * ```\n\t *\n\t * ---\n\t * **2. Overriding**\n\t *\n\t * Similarly to how {@link https://developers.openfin.co/docs/platform-customization#section-customizing-platform-behavior Platform Overriding} works, you can override functions in the Interop Broker in `fin.Platform.init`. An example of that is shown below. Overriding `isConnectionAuthorized` and `isActionAuthorized` will allow you to control allowed connections and allowed actions.\n\t *\n\t * However, if there is custom functionality you wish to include in the Interop Broker, please let us know. We would like to provide better configuration options so that you don't have to continually maintain your own override code.\n\t *\n\t * ```js\n\t * fin.Platform.init({\n\t *     overrideCallback: async (Provider) => {\n\t *         class Override extends Provider {\n\t *             async getSnapshot() {\n\t *                 console.log('before getSnapshot')\n\t *                 const snapshot = await super.getSnapshot();\n\t *                 console.log('after getSnapshot')\n\t *                 return snapshot;\n\t *             }\n\t *\n\t *             async applySnapshot({ snapshot, options }) {\n\t *                 console.log('before applySnapshot')\n\t *                 const originalPromise = super.applySnapshot({ snapshot, options });\n\t *                 console.log('after applySnapshot')\n\t *\n\t *                 return originalPromise;\n\t *             }\n\t *         };\n\t *         return new Override();\n\t *     },\n\t *     interopOverride: async (InteropBroker) => {\n\t *         class Override extends InteropBroker {\n\t *             async joinContextGroup(channelName = 'default', target) {\n\t *                 console.log('before super joinContextGroup')\n\t *                 super.joinContextGroup(channelName, target);\n\t *                 console.log('after super joinContextGroup')\n\t *             }\n\t *         }\n\t *\n\t *       return new Override();\n\t *   }\n\t * });\n\t * ```\n\t *\n\t * ---\n\t *\n\t */\n\tlet InteropBroker$1 = class InteropBroker extends base_1.Base {\n\t    /**\n\t     * @internal\n\t     */\n\t    constructor(wire, createProvider, options) {\n\t        // Tip from Pierre and Michael from the overrideCheck work: Don't use bound methods for overrideable InteropBroker functions.\n\t        super(wire);\n\t        _InteropBroker_fdc3Info.set(this, void 0);\n\t        _InteropBroker_contextGroups.set(this, void 0);\n\t        _InteropBroker_providerPromise.set(this, void 0);\n\t        this.getProvider = () => {\n\t            return __classPrivateFieldGet(this, _InteropBroker_providerPromise, \"f\").getValue();\n\t        };\n\t        this.interopClients = new Map();\n\t        this.contextGroupsById = new Map();\n\t        __classPrivateFieldSet(this, _InteropBroker_contextGroups, options.contextGroups ?? [...defaultContextGroups], \"f\");\n\t        __classPrivateFieldSet(this, _InteropBroker_fdc3Info, options.fdc3Info, \"f\");\n\t        if (options?.logging) {\n\t            this.logging = options.logging;\n\t        }\n\t        this.intentClientMap = new Map();\n\t        this.lastContextMap = new Map();\n\t        this.sessionContextGroupMap = new Map();\n\t        __classPrivateFieldSet(this, _InteropBroker_providerPromise, new lazy_1.Lazy(createProvider), \"f\");\n\t        this.setContextGroupMap();\n\t        this.setupChannelProvider();\n\t    }\n\t    static createClosedConstructor(...args) {\n\t        return class OverrideableBroker extends InteropBroker {\n\t            constructor(...unused) {\n\t                if (unused.length) {\n\t                    const [_ignore1, ignore2, opts] = unused;\n\t                    if (opts && typeof opts === 'object' && !(0, isEqual_1.default)(opts, args[2])) {\n\t                        // eslint-disable-next-line no-console\n\t                        console.warn('You have modified the parameters of the InteropOverride constructor. This behavior is deprecated and will be removed in a future version. You can modify these options in your manifest. Please consult our Interop docs for guidance on migrating to the new override scheme.');\n\t                        super(args[0], args[1], opts);\n\t                        return;\n\t                    }\n\t                    // eslint-disable-next-line no-console\n\t                    console.warn('You are attempting to pass arguments to the InteropOverride constructor. This is not necessary, and these passed arguments will be ignored. You are likely using an older InteropBroker override scheme. Please consult our Interop docs for guidance on migrating to the new override scheme.');\n\t                }\n\t                super(...args);\n\t            }\n\t        };\n\t    }\n\t    /*\n\t    Client API\n\t    */\n\t    /**\n\t     * Sets a context for the context group of the incoming current entity.\n\t     * @param setContextOptions - New context to set.\n\t     * @param clientIdentity - Identity of the client sender.\n\t     *\n\t     */\n\t    setContext({ context }, clientIdentity) {\n\t        this.wire.sendAction('interop-broker-set-context').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const clientState = this.getClientState(clientIdentity);\n\t        if (clientState && clientState.contextGroupId) {\n\t            const { contextGroupId } = clientState;\n\t            this.setContextForGroup({ context }, contextGroupId);\n\t        }\n\t        else if (clientState) {\n\t            // Client has not joined any context group behavior.\n\t            throw new Error('You must join a context group before you can set context.');\n\t        }\n\t        else {\n\t            // This shouldn't get hit.\n\t            throw new Error(`Client with Identity: ${clientIdentity.uuid} ${clientIdentity.name} not in Client State Map`);\n\t        }\n\t    }\n\t    /**\n\t     * Sets a context for the context group.\n\t     * @param setContextOptions - New context to set.\n\t     * @param contextGroupId - Context group id.\n\t     *\n\t     */\n\t    setContextForGroup({ context }, contextGroupId) {\n\t        this.wire.sendAction('interop-broker-set-context-for-group').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const contextGroupState = this.contextGroupsById.get(contextGroupId);\n\t        if (!contextGroupState) {\n\t            throw new Error(`Unable to set context for context group that isn't in the context group mapping: ${contextGroupId}.`);\n\t        }\n\t        const contextIntegrityCheckResult = InteropBroker.checkContextIntegrity(context);\n\t        if (contextIntegrityCheckResult.isValid === false) {\n\t            throw new Error(`Failed to set Context - bad Context. Reason: ${contextIntegrityCheckResult.reason}. Context: ${JSON.stringify(context)}`);\n\t        }\n\t        const broadcastedContextType = context.type;\n\t        contextGroupState.set(broadcastedContextType, context);\n\t        this.lastContextMap.set(contextGroupId, broadcastedContextType);\n\t        const clientsInSameContextGroup = Array.from(this.interopClients.values()).filter((connectedClient) => connectedClient.contextGroupId === contextGroupId);\n\t        clientsInSameContextGroup.forEach((client) => {\n\t            for (const [, handlerInfo] of client.contextHandlers) {\n\t                if (InteropBroker.isContextTypeCompatible(broadcastedContextType, handlerInfo.contextType)) {\n\t                    this.invokeContextHandler(client.clientIdentity, handlerInfo.handlerId, context);\n\t                }\n\t            }\n\t        });\n\t    }\n\t    /**\n\t     * Get current context for a client subscribed to a Context Group.\n\t     *\n\t     * @remarks It takes an optional Context Type argument and returns the last context of that type.\n\t     *\n\t     * @param getContextOptions - Options for getting context\n\t     * @param clientIdentity - Identity of the client sender.\n\t     *\n\t     */\n\t    getCurrentContext(getCurrentContextOptions, clientIdentity) {\n\t        this.wire.sendAction('interop-broker-get-current-context').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const clientState = this.getClientState(clientIdentity);\n\t        if (!clientState?.contextGroupId) {\n\t            throw new Error('You must be a member of a context group to call getCurrentContext');\n\t        }\n\t        const { contextGroupId } = clientState;\n\t        const contextGroupState = this.contextGroupsById.get(contextGroupId);\n\t        const lastContextType = this.lastContextMap.get(contextGroupId);\n\t        const contextType = getCurrentContextOptions?.contextType ?? lastContextType;\n\t        return contextGroupState && contextType ? contextGroupState.get(contextType) : undefined;\n\t    }\n\t    /*\n\t    Platform Window APIs\n\t    */\n\t    // joinContextGroup and addClientToContextGroup are separate functions here, for easier overrides and separation of concerns.\n\t    // joinContextGroup checks all connections for matching identities, in case we have multiple connection from an entity.\n\t    /**\n\t     * Join all connections at the given identity (or just one if endpointId provided) to context group `contextGroupId`.\n\t     * If no target is specified, it adds the sender to the context group.\n\t     * joinContextGroup is responsible for checking connections at the incoming identity. It calls {@link InteropBroker#addClientToContextGroup InteropBroker.addClientToContextGroup} to actually group the client.\n\t     * Used by Platform Windows.\n\t     *\n\t     * @param joinContextGroupOptions - Id of the Context Group and identity of the entity to join to the group.\n\t     * @param senderIdentity - Identity of the client sender.\n\t     */\n\t    async joinContextGroup({ contextGroupId, target }, senderIdentity) {\n\t        this.wire.sendAction('interop-broker-join-context-group').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        if (this.sessionContextGroupMap.has(contextGroupId)) {\n\t            throw new Error(utils_1.BROKER_ERRORS.joinSessionContextGroupWithJoinContextGroup);\n\t        }\n\t        if (target) {\n\t            // If an endpointId is provided, use that. This will likely be used by external adapters.\n\t            if (InteropBroker.hasEndpointId(target)) {\n\t                await this.addClientToContextGroup({ contextGroupId }, target);\n\t            }\n\t            // Sanity check here in case a single app has multiple connections\n\t            try {\n\t                const allConnections = this.channel.connections.filter((x) => x.uuid === target.uuid && x.name === target.name);\n\t                if (!allConnections.length) {\n\t                    throw new Error(`Given Identity ${target.uuid} ${target.name} is not connected to the Interop Broker.`);\n\t                }\n\t                if (allConnections.length > 1) {\n\t                    // Should figure out how we want to handle this situation. In the meantime, just change context group for all connections.\n\t                    console.warn(`More than one connection found for identity ${target.uuid} ${target.name}`);\n\t                }\n\t                const promises = [];\n\t                for (const connection of allConnections) {\n\t                    promises.push(this.addClientToContextGroup({ contextGroupId }, connection));\n\t                }\n\t                await Promise.all(promises);\n\t            }\n\t            catch (error) {\n\t                throw new Error(error);\n\t            }\n\t        }\n\t        else {\n\t            // No target provided, add the sender to the context group.\n\t            await this.addClientToContextGroup({ contextGroupId }, senderIdentity);\n\t        }\n\t    }\n\t    // addClientToContextGroup does the actual addition of the client to the Context Group\n\t    /**\n\t     * Helper function for {@link InteropBroker#joinContextGroup InteropBroker.joinContextGroup}. Does the work of actually adding the client to the Context Group.\n\t     * Used by Platform Windows.\n\t     *\n\t     * @param addClientToContextGroupOptions - Contains the contextGroupId\n\t     * @param clientIdentity - Identity of the client sender.\n\t     */\n\t    async addClientToContextGroup({ contextGroupId }, clientIdentity) {\n\t        this.wire.sendAction('interop-broker-add-client-to-context-group').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const clientSubscriptionState = this.getClientState(clientIdentity);\n\t        if (!clientSubscriptionState) {\n\t            throw new Error(`Client with Identity: ${clientIdentity.uuid} ${clientIdentity.name} not in Client State Map`);\n\t        }\n\t        if (!this.getContextGroups().find((contextGroupInfo) => contextGroupInfo.id === contextGroupId)) {\n\t            throw new Error(`Attempting to join a context group that does not exist: ${contextGroupId}. You may only join existing context groups.`);\n\t        }\n\t        const oldContextGroupId = clientSubscriptionState.contextGroupId;\n\t        if (oldContextGroupId !== contextGroupId) {\n\t            clientSubscriptionState.contextGroupId = contextGroupId;\n\t            await this.setCurrentContextGroupInClientOptions(clientIdentity, contextGroupId);\n\t            const contextGroupMap = this.contextGroupsById.get(contextGroupId);\n\t            for (const [, handlerInfo] of clientSubscriptionState.contextHandlers) {\n\t                const { contextType, handlerId } = handlerInfo;\n\t                if (contextType === undefined) {\n\t                    // Send this single handler all of the context, because it accepts all.\n\t                    contextGroupMap.forEach((context, _) => {\n\t                        this.invokeContextHandler(clientIdentity, handlerId, context);\n\t                    });\n\t                }\n\t                else if (contextGroupMap.has(contextType)) {\n\t                    const contextForType = contextGroupMap.get(contextType);\n\t                    if (contextForType) {\n\t                        this.invokeContextHandler(clientIdentity, handlerId, contextForType);\n\t                    }\n\t                }\n\t            }\n\t        }\n\t    }\n\t    // Removes the target from its context group. Similar structure to joinContextGroup.\n\t    /**\n\t     * Removes the specified target from a context group.\n\t     * If no target is specified, it removes the sender from their context group.\n\t     * removeFromContextGroup is responsible for checking connections at the incoming identity.\n\t     *\n\t     * @remarks It calls {@link InteropBroker#removeClientFromContextGroup InteropBroker.removeClientFromContextGroup} to actually ungroup\n\t     * the client. Used by Platform Windows.\n\t     *\n\t     * @param removeFromContextGroupOptions - Contains the target identity to remove.\n\t     * @param senderIdentity - Identity of the client sender.\n\t     */\n\t    async removeFromContextGroup({ target }, senderIdentity) {\n\t        this.wire.sendAction('interop-broker-remove-from-context-group').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        if (target) {\n\t            // If an endpointId is provided, use that. This will likely be used by external adapters.\n\t            if (InteropBroker.hasEndpointId(target)) {\n\t                await this.removeClientFromContextGroup(target);\n\t            }\n\t            try {\n\t                // Sanity check here in case a single app has multiple connections\n\t                const allConnections = this.channel.connections.filter((x) => x.uuid === target.uuid && x.name === target.name);\n\t                if (!allConnections.length) {\n\t                    throw new Error(`No connection found for given Identity ${target.uuid} ${target.name}`);\n\t                }\n\t                if (allConnections.length > 1) {\n\t                    console.warn(`More than one connection found for identity ${target.uuid} ${target.name}`);\n\t                }\n\t                const promises = [];\n\t                for (const connection of allConnections) {\n\t                    promises.push(this.removeClientFromContextGroup(connection));\n\t                }\n\t                await Promise.all(promises);\n\t            }\n\t            catch (error) {\n\t                throw new Error(error);\n\t            }\n\t        }\n\t        else {\n\t            // No target provided, remove the sender from the context group.\n\t            await this.removeClientFromContextGroup(senderIdentity);\n\t        }\n\t    }\n\t    // removeClientFromContextGroup does the actual remove of the client from the Context Group\n\t    /**\n\t     * Helper function for {@link InteropBroker#removeFromContextGroup InteropBroker.removeFromContextGroup}. Does the work of actually removing the client from the Context Group.\n\t     * Used by Platform Windows.\n\t     *\n\t     * @property { ClientIdentity } clientIdentity - Identity of the client sender.\n\t     */\n\t    async removeClientFromContextGroup(clientIdentity) {\n\t        this.wire.sendAction('interop-broker-remove-client-from-context-group').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const clientState = this.getClientState(clientIdentity);\n\t        if (clientState) {\n\t            clientState.contextGroupId = undefined;\n\t        }\n\t        await this.setCurrentContextGroupInClientOptions(clientIdentity, null);\n\t    }\n\t    // Used by platform windows to know what client groups the provider has declared. Also used internally to access context groups. Overrideable so that the platform developer can modify it.\n\t    /**\n\t     * Returns the Interop-Broker-defined context groups available for an entity to join. Because this function is used in the rest of the Interop Broker to fetch the Context Groups, overriding this allows you to customize the Context Groups for the Interop Broker. However, we recommend customizing the context groups through configuration instead.\n\t     * Used by Platform Windows.\n\t     *\n\t     */\n\t    // eslint-disable-next-line class-methods-use-this\n\t    getContextGroups() {\n\t        this.wire.sendAction('interop-broker-get-context-groups').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        // Create copy for immutability\n\t        return __classPrivateFieldGet(this, _InteropBroker_contextGroups, \"f\").map((contextGroup) => {\n\t            return { ...contextGroup };\n\t        });\n\t    }\n\t    // Used to by platform windows to get display metadata for a context group.\n\t    /**\n\t     * Gets display info for a context group\n\t     *\n\t     * @remarks Used by Platform Windows.\n\t     *\n\t     * @param getInfoForContextGroupOptions - Contains contextGroupId, the context group you wish to get display info for.\n\t     *\n\t     */\n\t    getInfoForContextGroup({ contextGroupId }) {\n\t        this.wire.sendAction('interop-broker-get-info-for-context-group').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        return this.getContextGroups().find((contextGroup) => contextGroup.id === contextGroupId);\n\t    }\n\t    // Used by platform windows to get all clients for a context group.\n\t    /**\n\t     * Gets all clients for a context group.\n\t     *\n\t     * @remarks **This is primarily used for platform windows. Views within a platform should not have to use this API.**\n\t     * Returns the Interop-Broker-defined context groups available for an entity to join.\n\t     *\n\t     * @param getAllClientsInContextGroupOptions - Contains contextGroupId, the context group you wish to get clients for.\n\t     *\n\t     */\n\t    getAllClientsInContextGroup({ contextGroupId }) {\n\t        this.wire.sendAction('interop-broker-get-all-clients-in-context-group').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const clientsInContextGroup = Array.from(this.interopClients.values())\n\t            .filter((connectedClient) => connectedClient.contextGroupId === contextGroupId)\n\t            .map((subscriptionState) => {\n\t            return subscriptionState.clientIdentity;\n\t        });\n\t        return clientsInContextGroup;\n\t    }\n\t    /**\n\t     * Responsible for launching of applications that can handle a given intent, and delegation of intents to those applications.\n\t     * Must be overridden.\n\t     *\n\t     * @remarks To make this call FDC3-Compliant it would need to return an IntentResolution.\n\t     *\n\t     * ```js\n\t     * interface IntentResolution {\n\t     *   source: TargetApp;\n\t     *   // deprecated, not assignable from intent listeners\n\t     *   data?: object;\n\t     *   version: string;\n\t     * }\n\t     * ```\n\t     *\n\t     * More information on the IntentResolution type can be found in the [FDC3 documentation](https://fdc3.finos.org/docs/api/ref/IntentResolution).\n\t     *\n\t     * @param intent The combination of an action and a context that is passed to an application for resolution.\n\t     * @param  clientIdentity Identity of the Client making the request.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * // override call so we set intent target and create view that will handle it\n\t     * fin.Platform.init({\n\t     *     interopOverride: async (InteropBroker) => {\n\t     *         class Override extends InteropBroker {\n\t     *             async handleFiredIntent(intent) {\n\t     *                 super.setIntentTarget(intent, { uuid: 'platform-uuid', name: 'intent-view' });\n\t     *                 const platform = fin.Platform.getCurrentSync();\n\t     *                 const win = fin.Window.wrapSync({ name: 'foo', uuid: 'platform-uuid' });\n\t     *                 const createdView = await platform.createView({ url: 'http://openfin.co', name: 'intent-view' }, win.identity);\n\t     *             }\n\t     *         }\n\t     *         return new Override();\n\t     *     }\n\t     * });\n\t     * ```\n\t     */\n\t    // eslint-disable-next-line class-methods-use-this\n\t    async handleFiredIntent(intent, clientIdentity // TODO(CORE-811): remove inline intersected type\n\t    ) {\n\t        const warning = (0, utils_1.generateOverrideWarning)('fdc3.raiseIntent', 'InteropBroker.handleFiredIntent', clientIdentity, 'interopClient.fireIntent');\n\t        console.warn(warning);\n\t        throw new Error(utils_1.BROKER_ERRORS.fireIntent);\n\t    }\n\t    /**\n\t     * Should be called in {@link InteropBroker#handleFiredIntent InteropBroker.handleFiredIntent}.\n\t     * While handleFiredIntent is responsible for launching applications, setIntentTarget is used to tell the InteropBroker which application should receive the intent when it is ready.\n\t     * @param intent The combination of an action and a context that is passed to an application for resolution.\n\t     * @param target - Identity of the target that will handle the intent.\n\t     *\n\t     */\n\t    async setIntentTarget(intent, target) {\n\t        this.wire.sendAction('interop-broker-set-intent-target').catch((e) => {\n\t            // don't expose, this is only for api analytics purposes\n\t        });\n\t        const targetInfo = this.intentClientMap.get(target.name);\n\t        const handlerId = `intent-handler-${intent.name}`;\n\t        if (!targetInfo) {\n\t            this.intentClientMap.set(target.name, new Map());\n\t            const newHandlerInfoMap = this.intentClientMap.get(target.name);\n\t            if (newHandlerInfoMap) {\n\t                newHandlerInfoMap.set(handlerId, { isReady: false, pendingIntents: [intent] });\n\t            }\n\t        }\n\t        else {\n\t            const handlerInfo = targetInfo.get(handlerId);\n\t            if (!handlerInfo) {\n\t                targetInfo.set(handlerId, { isReady: false, pendingIntents: [intent] });\n\t            }\n\t            else {\n\t                handlerInfo.pendingIntents.push(intent);\n\t                if (handlerInfo.clientIdentity && handlerInfo.isReady) {\n\t                    const { clientIdentity, pendingIntents } = handlerInfo;\n\t                    try {\n\t                        const intentToSend = pendingIntents[pendingIntents.length - 1];\n\t                        await this.invokeIntentHandler(clientIdentity, handlerId, intentToSend);\n\t                        handlerInfo.pendingIntents = [];\n\t                    }\n\t                    catch (error) {\n\t                        console.error(`Error invoking intent handler for client ${clientIdentity.uuid}/${clientIdentity.name}/${clientIdentity.endpointId}`);\n\t                        handlerInfo.isReady = false;\n\t                    }\n\t                }\n\t            }\n\t        }\n\t    }\n\t    /**\n\t     * Responsible for returning information on a particular Intent.\n\t     *\n\t     * @remarks Whenever InteropClient.getInfoForIntent is called this function will fire. The options argument gives you\n\t     * access to the intent name and any optional context that was passed and clientIdentity is the identity of the client\n\t     * that made the call. Ideally here you would fetch the info for the intent and return it with the shape that the\n\t     * InteropClient.getInfoForIntent call is expecting.\n\t     *\n\t     * To make this call FDC3-Compliant it would need to return an App Intent:\n\t     *\n\t     * ```js\n\t     * // {\n\t     * //     intent: { name: \"StartChat\", displayName: \"Chat\" },\n\t     * //     apps: [{ name: \"Skype\" }, { name: \"Symphony\" }, { name: \"Slack\" }]\n\t     * // }\n\t     * ```\n\t     *\n\t     * More information on the AppIntent type can be found in the [FDC3 documentation](https://fdc3.finos.org/docs/api/ref/AppIntent).\n\t     *\n\t     * @param options\n\t     * @param clientIdentity Identity of the Client making the request.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.Platform.init({\n\t     *     interopOverride: async (InteropBroker) => {\n\t     *         class Override extends InteropBroker {\n\t     *             async handleInfoForIntent(options, clientIdentity) {\n\t     *                 // Your code goes here.\n\t     *             }\n\t     *         }\n\t     *         return new Override();\n\t     *     }\n\t     * });\n\t     * ```\n\t     */\n\t    // eslint-disable-next-line class-methods-use-this\n\t    async handleInfoForIntent(options, clientIdentity // TODO(CORE-811): remove inline intersected type\n\t    ) {\n\t        const warning = (0, utils_1.generateOverrideWarning)('fdc3.findIntent', 'InteropBroker.handleInfoForIntent', clientIdentity, 'interopClient.getInfoForIntent');\n\t        console.warn(warning);\n\t        throw new Error(utils_1.BROKER_ERRORS.getInfoForIntent);\n\t    }\n\t    /**\n\t     * Responsible for returning information on which Intents are meant to handle a specific Context.\n\t     * Must be overridden.\n\t     *\n\t     * @remarks Responsible for returning information on which Intents are meant to handle a specific Context. Must be overridden.\n\t     *\n\t     * Whenever InteropClient.getInfoForIntentsByContext is called this function will fire. The context argument gives you access to the context that the client wants information on and clientIdentity is the identity of the client that made the call. Ideally here you would fetch the info for any intent that can handle and return it with the shape that the InteropClient.getInfoForIntentsByContext call is expecting.\n\t     *\n\t     * To make this call FDC3-Compliant it would need to return an array of AppIntents:\n\t     *\n\t     * ```js\n\t     * // [{\n\t     * //     intent: { name: \"StartCall\", displayName: \"Call\" },\n\t     * //     apps: [{ name: \"Skype\" }]\n\t     * // },\n\t     * // {\n\t     * //     intent: { name: \"StartChat\", displayName: \"Chat\" },\n\t     * //     apps: [{ name: \"Skype\" }, { name: \"Symphony\" }, { name: \"Slack\" }]\n\t     * // }];\n\t     * ```\n\t     *\n\t     * More information on the AppIntent type can be found in the [FDC3 documentation](https://fdc3.finos.org/docs/api/ref/AppIntent).\n\t     *\n\t     * @param context Data passed between entities and applications.\n\t     * @param clientIdentity Identity of the Client making the request.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.Platform.init({\n\t     *     interopOverride: async (InteropBroker) => {\n\t     *         class Override extends InteropBroker {\n\t     *             async handleInfoForIntentsByContext(context, clientIdentity) {\n\t     *                 // Your code goes here.\n\t     *             }\n\t     *         }\n\t     *         return new Override();\n\t     *     }\n\t     * });\n\t     * ```\n\t     */\n\t    // eslint-disable-next-line class-methods-use-this\n\t    async handleInfoForIntentsByContext(context, clientIdentity // TODO(CORE-811): remove inline intersected type\n\t    ) {\n\t        const warning = (0, utils_1.generateOverrideWarning)('fdc3.findIntentsByContext', 'InteropBroker.handleInfoForIntentsByContext', clientIdentity, 'interopClient.getInfoForIntentsByContext');\n\t        console.warn(warning);\n\t        throw new Error(utils_1.BROKER_ERRORS.getInfoForIntentsByContext);\n\t    }\n\t    /**\n\t     * Responsible for resolving an Intent based on a specific Context.\n\t     * Must be overridden.\n\t     *\n\t     * @remarks Whenever InteropClient.fireIntentForContext is called this function will fire. The contextForIntent argument\n\t     * gives you access to the context that will be resolved to an intent. It also can optionally contain any metadata relevant\n\t     * to resolving it, like a specific app the client wants the context to be handled by. The clientIdentity is the identity\n\t     * of the client that made the call.\n\t     *\n\t     * To make this call FDC3-Compliant it would need to return an IntentResolution:\n\t     *\n\t     * ```js\n\t     * // {\n\t     * //     intent: { name: \"StartChat\", displayName: \"Chat\" },\n\t     * //     apps: [{ name: \"Skype\" }, { name: \"Symphony\" }, { name: \"Slack\" }]\n\t     * // }\n\t     * ```\n\t     *\n\t     * More information on the IntentResolution type can be found in the [FDC3 documentation](https://fdc3.finos.org/docs/api/ref/Metadata#intentresolution).\n\t     *\n\t     * @param contextForIntent Data passed between entities and applications.\n\t     * @param clientIdentity Identity of the Client making the request.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.Platform.init({\n\t     *     interopOverride: async (InteropBroker) => {\n\t     *         class Override extends InteropBroker {\n\t     *             async handleFiredIntentForContext(contextForIntent, clientIdentity) {\n\t     *                 // Your code goes here.\n\t     *             }\n\t     *         }\n\t     *         return new Override();\n\t     *     }\n\t     * });\n\t     * ```\n\t     */\n\t    // eslint-disable-next-line class-methods-use-this\n\t    async handleFiredIntentForContext(contextForIntent, clientIdentity) {\n\t        const warning = (0, utils_1.generateOverrideWarning)('fdc3.raiseIntentForContext', 'InteropBroker.handleFiredIntentForContext', clientIdentity, 'interopClient.fireIntentForContext');\n\t        console.warn(warning);\n\t        throw new Error(utils_1.BROKER_ERRORS.fireIntentForContext);\n\t    }\n\t    /**\n\t     * Provides the identity of any Interop Client that disconnects from the Interop Broker. It is meant to be overriden.\n\t     * @param clientIdentity\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.Platform.init({\n\t     *     interopOverride: async (InteropBroker) => {\n\t     *         class Override extends InteropBroker {\n\t     *             async clientDisconnected(clientIdentity) {\n\t     *                 const { uuid, name } = clientIdentity;\n\t     *                 console.log(`Client with identity ${uuid}/${name} has been disconnected`);\n\t     *             }\n\t     *         }\n\t     *         return new Override();\n\t     *     }\n\t     * });\n\t     * ```\n\t     */\n\t    // eslint-disable-next-line class-methods-use-this\n\t    async clientDisconnected(clientIdentity) {\n\t        // This function is called in channel.onDisconnection.\n\t        // It is meant to be overridden to inform when an Interop Client has been disconnected.\n\t    }\n\t    /**\n\t     * Responsible for resolving an fdc3.open call.\n\t     * Must be overridden.\n\t     * @param fdc3OpenOptions fdc3.open options\n\t     * @param clientIdentity Identity of the Client making the request.\n\t     */\n\t    // eslint-disable-next-line class-methods-use-this\n\t    async fdc3HandleOpen({ app, context }, clientIdentity) {\n\t        const warning = (0, utils_1.generateOverrideWarning)('fdc3.open', 'InteropBroker.fdc3HandleOpen', clientIdentity);\n\t        console.warn(warning);\n\t        throw new Error(utils_1.BROKER_ERRORS.fdc3Open);\n\t    }\n\t    /**\n\t     * Responsible for resolving the fdc3.findInstances call.\n\t     * Must be overridden\n\t     * @param app AppIdentifier that was passed to fdc3.findInstances\n\t     * @param clientIdentity Identity of the Client making the request.\n\t     */\n\t    // eslint-disable-next-line class-methods-use-this\n\t    async fdc3HandleFindInstances(app, clientIdentity) {\n\t        const warning = (0, utils_1.generateOverrideWarning)('fdc3.open', 'InteropBroker.fdc3HandleFindInstances', clientIdentity);\n\t        console.warn(warning);\n\t        throw new Error(utils_1.BROKER_ERRORS.fdc3FindInstances);\n\t    }\n\t    /**\n\t     * Responsible for resolving the fdc3.getAppMetadata call.\n\t     * Must be overridden\n\t     * @param app AppIdentifier that was passed to fdc3.getAppMetadata\n\t     * @param clientIdentity Identity of the Client making the request.\n\t     */\n\t    // eslint-disable-next-line class-methods-use-this\n\t    async fdc3HandleGetAppMetadata(app, clientIdentity) {\n\t        const warning = (0, utils_1.generateOverrideWarning)('fdc3.getAppMetadata', 'InteropBroker.fdc3HandleGetAppMetadata', clientIdentity);\n\t        console.warn(warning);\n\t        throw new Error(utils_1.BROKER_ERRORS.fdc3GetAppMetadata);\n\t    }\n\t    /**\n\t     * This function is called by the Interop Broker whenever a Context handler would fire.\n\t     * For FDC3 2.0 you would need to override this function and add the contextMetadata as\n\t     * part of the Context object. Then would you need to call\n\t     * super.invokeContextHandler passing it this new Context object along with the clientIdentity and handlerId\n\t     * @param clientIdentity\n\t     * @param handlerId\n\t     * @param context\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.Platform.init({\n\t     *     interopOverride: async (InteropBroker) => {\n\t     *         class Override extends InteropBroker {\n\t     *             async invokeContextHandler(clientIdentity, handlerId, context) {\n\t     *                 return super.invokeContextHandler(clientIdentity, handlerId, {\n\t     *                     ...context,\n\t     *                     contextMetadata: {\n\t     *                         source: {\n\t     *                             appId: 'openfin-app',\n\t     *                             instanceId: '3D54D456D9HT0'\n\t     *                         }\n\t     *                     }\n\t     *                 });\n\t     *             }\n\t     *         }\n\t     *         return new Override();\n\t     *     }\n\t     * });\n\t     * ```\n\t     */\n\t    async invokeContextHandler(clientIdentity, handlerId, context) {\n\t        const provider = await this.getProvider();\n\t        try {\n\t            await provider.dispatch(clientIdentity, handlerId, context);\n\t        }\n\t        catch (error) {\n\t            console.error(`Error invoking context handler ${handlerId} for context type ${context.type} in client ${clientIdentity.uuid}/${clientIdentity.name}/${clientIdentity.endpointId}`, error);\n\t        }\n\t    }\n\t    /**\n\t     * This function is called by the Interop Broker whenever an Intent handler would fire.\n\t     * For FDC3 2.0 you would need to override this function and add the contextMetadata as\n\t     * part of the Context object inside the Intent object. Then would you need to call\n\t     * super.invokeIntentHandler passing it this new Intent object along with the clientIdentity and handlerId\n\t     * @param ClientIdentity\n\t     * @param handlerId\n\t     * @param context\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.Platform.init({\n\t     *     interopOverride: async (InteropBroker) => {\n\t     *         class Override extends InteropBroker {\n\t     *             async invokeIntentHandler(clientIdentity, handlerId, context) {\n\t     *                 const { context } = intent;\n\t     *                 return super.invokeIntentHandler(clientIdentity, handlerId, {\n\t     *                     ...intent,\n\t     *                     context: {\n\t     *                         ...context,\n\t     *                         contextMetadata: {\n\t     *                             source: {\n\t     *                                 appId: 'openfin-app',\n\t     *                                 instanceId: '3D54D456D9HT0'\n\t     *                             }\n\t     *                         }\n\t     *                     }\n\t     *                 });\n\t     *             }\n\t     *         }\n\t     *         return new Override();\n\t     *     }\n\t     * });\n\t     * ```\n\t     */\n\t    async invokeIntentHandler(clientIdentity, handlerId, intent) {\n\t        const provider = await this.getProvider();\n\t        await provider.dispatch(clientIdentity, handlerId, intent);\n\t    }\n\t    /**\n\t     * Responsible for resolving fdc3.getInfo for FDC3 2.0\n\t     * Would need to return the optionalFeatures and appMetadata for the {@link https://fdc3.finos.org/docs/api/ref/Metadata#implementationmetadata ImplementationMetadata}.\n\t     * Must be overridden.\n\t     * @param clientIdentity\n\t     *\n\t     */\n\t    // eslint-disable-next-line class-methods-use-this\n\t    async fdc3HandleGetInfo(payload, clientIdentity) {\n\t        const { fdc3Version } = payload;\n\t        return {\n\t            fdc3Version,\n\t            ...__classPrivateFieldGet(this, _InteropBroker_fdc3Info, \"f\"),\n\t            optionalFeatures: {\n\t                OriginatingAppMetadata: false,\n\t                UserChannelMembershipAPIs: true\n\t            },\n\t            appMetadata: {\n\t                appId: '',\n\t                instanceId: ''\n\t            }\n\t        };\n\t    }\n\t    /**\n\t     * Returns an array of info for each Interop Client connected to the Interop Broker.\n\t     *\n\t     * FDC3 2.0: Use the endpointId in the ClientInfo as the instanceId when generating\n\t     * an AppIdentifier.\n\t     *\n\t     * @remarks FDC3 2.0 Note: When needing an instanceId to generate an AppIdentifier use this call to\n\t     * get the endpointId and use it as the instanceId. In the Example below we override handleFiredIntent\n\t     * and then call super.getAllClientInfo to generate the AppIdentifier for the IntentResolution.\n\t     *\n\t     *\n\t     * @example\n\t     * ```js\n\t     * // FDC3 2.0 Example:\n\t     * fin.Platform.init({\n\t     *     interopOverride: async (InteropBroker, ...args) => {\n\t     *         class Override extends InteropBroker {\n\t     *             async handleFiredIntent(intent) {\n\t     *                 super.setIntentTarget(intent, { uuid: 'platform-uuid', name: 'intent-view' });\n\t     *                 const platform = fin.Platform.getCurrentSync();\n\t     *                 const win = fin.Window.wrapSync({ name: 'foo', uuid: 'platform-uuid' });\n\t     *                 const createdView = await platform.createView({ url: 'http://openfin.co', name: 'intent-view' }, win.identity);\n\t     *\n\t     *                 const allClientInfo = await super.getAllClientInfo();\n\t     *\n\t     *                 const infoForTarget = allClientInfo.find((clientInfo) => {\n\t     *                     return clientInfo.uuid === 'platform-uuid' && clientInfo.name === 'intent-view';\n\t     *                 });\n\t     *\n\t     *                 const source = {\n\t     *                     appId: 'intent-view',\n\t     *                     instanceId: infoForTarget.endpointId\n\t     *                 }\n\t     *\n\t     *                 return {\n\t     *                     source,\n\t     *                     intent: intent.name\n\t     *                 }\n\t     *\n\t     *             }\n\t     *         }\n\t     *         return new Override(...args);\n\t     *     }\n\t     * });\n\t     * ```\n\t     */\n\t    async getAllClientInfo() {\n\t        const provider = await this.getProvider();\n\t        return provider.getAllClientInfo();\n\t    }\n\t    /*\n\t    Snapshot APIs\n\t    */\n\t    // Used to save interop broker state in snapshots\n\t    decorateSnapshot(snapshot) {\n\t        return { ...snapshot, interopSnapshotDetails: { contextGroupStates: this.getContextGroupStates() } };\n\t    }\n\t    // Used to restore interop broker state in snapshots.\n\t    applySnapshot(snapshot, options) {\n\t        const contextGroupStates = snapshot?.interopSnapshotDetails?.contextGroupStates;\n\t        if (contextGroupStates) {\n\t            if (!options?.closeExistingWindows) {\n\t                this.updateExistingClients(contextGroupStates);\n\t            }\n\t            this.rehydrateContextGroupStates(contextGroupStates);\n\t        }\n\t    }\n\t    updateExistingClients(contextGroupStates) {\n\t        const clients = this.interopClients;\n\t        clients.forEach((subState) => {\n\t            const { clientIdentity, contextGroupId, contextHandlers } = subState;\n\t            if (contextGroupId) {\n\t                const groupContexts = contextGroupStates[contextGroupId];\n\t                for (const [, context] of Object.entries(groupContexts)) {\n\t                    contextHandlers.forEach((contextHandler) => {\n\t                        const { handlerId, contextType } = contextHandler;\n\t                        if (InteropBroker.isContextTypeCompatible(context.type, contextType)) {\n\t                            this.invokeContextHandler(clientIdentity, handlerId, context);\n\t                        }\n\t                    });\n\t                }\n\t            }\n\t        });\n\t    }\n\t    // Used to store context group state in snapshots\n\t    getContextGroupStates() {\n\t        return InteropBroker.toObject(this.contextGroupsById);\n\t    }\n\t    // Used to rehydrate the context state from a snapshot\n\t    rehydrateContextGroupStates(incomingContextGroupStates) {\n\t        const contextGroupStates = Object.entries(incomingContextGroupStates);\n\t        for (const [contextGroupId, contexts] of contextGroupStates) {\n\t            const contextObjects = Object.entries(contexts);\n\t            for (const [contextType, context] of contextObjects) {\n\t                if (this.contextGroupsById.has(contextGroupId)) {\n\t                    const currentContextGroupState = this.contextGroupsById.get(contextGroupId);\n\t                    currentContextGroupState.set(contextType, context);\n\t                }\n\t                else {\n\t                    // This logic will change when dynamic context group creation comes in.\n\t                    console.warn(`Attempting to set a context group that isn't in the context group mapping. Skipping context group rehydration for: ${contextGroupId}`);\n\t                }\n\t            }\n\t        }\n\t    }\n\t    /*\n\t    Internal Context Handler APIs\n\t    */\n\t    // Used to give context to a client that has registered their context handler\n\t    contextHandlerRegistered({ contextType, handlerId }, clientIdentity) {\n\t        const handlerInfo = { contextType, handlerId };\n\t        const clientState = this.getClientState(clientIdentity);\n\t        clientState?.contextHandlers.set(handlerId, handlerInfo);\n\t        if (clientState && clientState.contextGroupId) {\n\t            const { contextGroupId } = clientState;\n\t            const contextGroupMap = this.contextGroupsById.get(contextGroupId);\n\t            if (contextType === undefined) {\n\t                // Send this single handler all of the context, because it accepts all.\n\t                contextGroupMap.forEach((context, _) => {\n\t                    this.invokeContextHandler(clientIdentity, handlerId, context);\n\t                });\n\t            }\n\t            else if (contextGroupMap.has(contextType)) {\n\t                const contextForType = contextGroupMap.get(contextType);\n\t                if (contextForType) {\n\t                    this.invokeContextHandler(clientIdentity, handlerId, contextForType);\n\t                }\n\t            }\n\t        }\n\t    }\n\t    // eslint-disable-next-line class-methods-use-this\n\t    async intentHandlerRegistered(payload, clientIdentity) {\n\t        const { handlerId } = payload;\n\t        const clientIntentInfo = this.intentClientMap.get(clientIdentity.name);\n\t        const handlerInfo = clientIntentInfo?.get(handlerId);\n\t        if (!clientIntentInfo) {\n\t            this.intentClientMap.set(clientIdentity.name, new Map());\n\t            const newHandlerInfoMap = this.intentClientMap.get(clientIdentity.name);\n\t            if (newHandlerInfoMap) {\n\t                newHandlerInfoMap.set(handlerId, { isReady: true, pendingIntents: [], clientIdentity });\n\t            }\n\t        }\n\t        else if (!handlerInfo) {\n\t            clientIntentInfo.set(handlerId, { isReady: true, pendingIntents: [], clientIdentity });\n\t        }\n\t        else {\n\t            const { pendingIntents } = handlerInfo;\n\t            handlerInfo.clientIdentity = clientIdentity;\n\t            handlerInfo.isReady = true;\n\t            try {\n\t                if (pendingIntents.length > 0) {\n\t                    const intentToSend = pendingIntents[pendingIntents.length - 1];\n\t                    await this.invokeIntentHandler(clientIdentity, handlerId, intentToSend);\n\t                    handlerInfo.pendingIntents = [];\n\t                }\n\t            }\n\t            catch (error) {\n\t                console.error(`Error invoking intent handler: ${handlerId} for client ${clientIdentity.uuid}/${clientIdentity.name}/${clientIdentity.endpointId}`);\n\t            }\n\t        }\n\t    }\n\t    // Used to remove a context handler for a client\n\t    removeContextHandler({ handlerId }, clientIdentity) {\n\t        const clientState = this.getClientState(clientIdentity);\n\t        if (clientState) {\n\t            clientState.contextHandlers.delete(handlerId);\n\t        }\n\t    }\n\t    handleJoinSessionContextGroup({ sessionContextGroupId }, clientIdentity) {\n\t        try {\n\t            if (!sessionContextGroupId) {\n\t                throw new Error('Failed to join session context group: must specify group id.');\n\t            }\n\t            const sessionContextGroup = this.sessionContextGroupMap.get(sessionContextGroupId);\n\t            if (sessionContextGroup) {\n\t                sessionContextGroup.registerNewClient(clientIdentity);\n\t            }\n\t            else {\n\t                const newSessionContextGroupBroker = new SessionContextGroupBroker_1.default(this.channel, sessionContextGroupId);\n\t                newSessionContextGroupBroker.registerNewClient(clientIdentity);\n\t                this.sessionContextGroupMap.set(sessionContextGroupId, newSessionContextGroupBroker);\n\t            }\n\t            return { hasConflict: this.contextGroupsById.has(sessionContextGroupId) };\n\t        }\n\t        catch (error) {\n\t            throw new Error(error);\n\t        }\n\t    }\n\t    /*\n\t    Internal Utilties\n\t    */\n\t    // Getter for interop info for a client.\n\t    getClientState(id) {\n\t        return this.interopClients.get(id.endpointId);\n\t    }\n\t    // Util for getContextGroupStates. Serializes the contextGroupStates object so we can store it.\n\t    static toObject(map) {\n\t        const objectFromMap = Object.fromEntries(map);\n\t        const newObject = {};\n\t        Object.entries(objectFromMap).forEach(([contextGroupId, contextMap]) => {\n\t            const newContextObject = Object.fromEntries(contextMap);\n\t            newObject[contextGroupId] = newContextObject;\n\t        });\n\t        return newObject;\n\t    }\n\t    static checkContextIntegrity(context) {\n\t        if (!context) {\n\t            return { isValid: false, reason: 'No context supplied' };\n\t        }\n\t        if (typeof context !== 'object') {\n\t            return { isValid: false, reason: 'Context must be an Object' };\n\t        }\n\t        if (!context.type) {\n\t            return { isValid: false, reason: 'Context must have a type property' };\n\t        }\n\t        if (context.id && typeof context.id !== 'object') {\n\t            return {\n\t                isValid: false,\n\t                reason: 'Context id must be an Object populated with key-value identifiers (if set)'\n\t            };\n\t        }\n\t        if (context.id) {\n\t            const { id } = context;\n\t            const keys = Object.keys(id);\n\t            let foundBadIdentifier = false;\n\t            if (!keys.length) {\n\t                return { isValid: false, reason: 'Context id must have at least one key-value identifier' };\n\t            }\n\t            keys.forEach((key) => {\n\t                if (typeof key !== 'string' || typeof id[key] !== 'string') {\n\t                    foundBadIdentifier = true;\n\t                }\n\t            });\n\t            if (foundBadIdentifier) {\n\t                return { isValid: false, reason: 'Context id key-value identifiers must be of type string' };\n\t            }\n\t        }\n\t        if (context.name && typeof context.name !== 'string') {\n\t            return { isValid: false, reason: 'Context name must be of string type (if set)' };\n\t        }\n\t        return { isValid: true };\n\t    }\n\t    // Util to check a client identity.\n\t    static hasEndpointId(target) {\n\t        return target.endpointId !== undefined;\n\t    }\n\t    // Util to check if we should send a context to a handler.\n\t    static isContextTypeCompatible(contextType, registeredContextType) {\n\t        return typeof registeredContextType === 'undefined' || contextType === registeredContextType;\n\t    }\n\t    // Setup function for state mapping\n\t    setContextGroupMap() {\n\t        // This way, if a user overrides this.getContextGroups, it's reflected in the contextGroupMapping.\n\t        for (const contextGroupInfo of this.getContextGroups()) {\n\t            this.contextGroupsById.set(contextGroupInfo.id, new Map());\n\t        }\n\t    }\n\t    async setCurrentContextGroupInClientOptions(clientIdentity, contextGroupId) {\n\t        try {\n\t            const entityInfo = await this.fin.System.getEntityInfo(clientIdentity.uuid, clientIdentity.name);\n\t            let entity;\n\t            if (entityInfo.entityType === 'view') {\n\t                entity = await this.fin.View.wrap(clientIdentity);\n\t            }\n\t            else if (entityInfo.entityType === 'window') {\n\t                entity = await this.fin.Window.wrap(clientIdentity);\n\t            }\n\t            if (entity) {\n\t                await entity.updateOptions({\n\t                    interop: {\n\t                        currentContextGroup: contextGroupId\n\t                    }\n\t                });\n\t            }\n\t        }\n\t        catch (error) {\n\t            //  May file in interop\n\t        }\n\t    }\n\t    async setupChannelProvider() {\n\t        try {\n\t            const channel = await this.getProvider();\n\t            this.channel = channel;\n\t            this.wireChannel(channel);\n\t        }\n\t        catch (error) {\n\t            throw new Error(`Error setting up Interop Broker Channel Provider: ${error}`);\n\t        }\n\t    }\n\t    // Setup Channel Connection Logic\n\t    wireChannel(channel) {\n\t        channel.onConnection(async (clientIdentity, // TODO(CORE-811): remove inline intersected type\n\t        payload) => {\n\t            if (!(await this.isConnectionAuthorized(clientIdentity, payload))) {\n\t                throw new Error(`Connection not authorized for ${clientIdentity.uuid}, ${clientIdentity.name}`);\n\t            }\n\t            if (!clientIdentity.endpointId) {\n\t                throw new Error('Version too old to be compatible with Interop. Please upgrade your runtime to a more recent version.');\n\t            }\n\t            const clientSubscriptionState = {\n\t                contextGroupId: undefined,\n\t                contextHandlers: new Map(),\n\t                clientIdentity\n\t            };\n\t            // Only allow the client to join a contextGroup that actually exists.\n\t            if (payload?.currentContextGroup && this.contextGroupsById.has(payload.currentContextGroup)) {\n\t                clientSubscriptionState.contextGroupId = payload?.currentContextGroup;\n\t            }\n\t            this.interopClients.set(clientIdentity.endpointId, clientSubscriptionState);\n\t        });\n\t        channel.onDisconnection((clientIdentity) => {\n\t            this.interopClients.delete(clientIdentity.endpointId);\n\t            const targetInfo = this.intentClientMap.get(clientIdentity.name);\n\t            if (targetInfo && clientIdentity.uuid === this.fin.me.uuid) {\n\t                targetInfo.forEach((handler) => {\n\t                    handler.isReady = false;\n\t                });\n\t            }\n\t            this.sessionContextGroupMap.forEach((sessionContextGroup) => {\n\t                sessionContextGroup.onDisconnection(clientIdentity);\n\t            });\n\t            this.clientDisconnected(clientIdentity);\n\t        });\n\t        channel.beforeAction(async (action, payload, clientIdentity) => {\n\t            if (!(await this.isActionAuthorized(action, payload, clientIdentity))) {\n\t                throw new Error(`Action (${action}) not authorized for ${clientIdentity.uuid}, ${clientIdentity.name}`);\n\t            }\n\t            if (this.logging?.beforeAction?.enabled) {\n\t                console.log(action, payload, clientIdentity);\n\t            }\n\t        });\n\t        channel.afterAction((action, payload, clientIdentity) => {\n\t            if (this.logging?.afterAction?.enabled) {\n\t                console.log(action, payload, clientIdentity);\n\t            }\n\t        });\n\t        // Client functions\n\t        channel.register('setContext', this.setContext.bind(this));\n\t        channel.register('fireIntent', this.handleFiredIntent.bind(this));\n\t        channel.register('getCurrentContext', this.getCurrentContext.bind(this));\n\t        channel.register('getInfoForIntent', this.handleInfoForIntent.bind(this));\n\t        channel.register('getInfoForIntentsByContext', this.handleInfoForIntentsByContext.bind(this));\n\t        channel.register('fireIntentForContext', this.handleFiredIntentForContext.bind(this));\n\t        // Platform window functions\n\t        channel.register('getContextGroups', this.getContextGroups.bind(this));\n\t        channel.register('joinContextGroup', this.joinContextGroup.bind(this));\n\t        channel.register('removeFromContextGroup', this.removeFromContextGroup.bind(this));\n\t        channel.register('getAllClientsInContextGroup', this.getAllClientsInContextGroup.bind(this));\n\t        channel.register('getInfoForContextGroup', this.getInfoForContextGroup.bind(this));\n\t        // Internal methods\n\t        channel.register('contextHandlerRegistered', this.contextHandlerRegistered.bind(this));\n\t        channel.register('intentHandlerRegistered', this.intentHandlerRegistered.bind(this));\n\t        channel.register('removeContextHandler', this.removeContextHandler.bind(this));\n\t        channel.register('sessionContextGroup:createIfNeeded', this.handleJoinSessionContextGroup.bind(this));\n\t        // fdc3 only methods\n\t        channel.register('fdc3Open', this.fdc3HandleOpen.bind(this));\n\t        channel.register('fdc3v2FindIntentsByContext', this.handleInfoForIntentsByContext.bind(this));\n\t        channel.register('fdc3FindInstances', this.fdc3HandleFindInstances.bind(this));\n\t        channel.register('fdc3GetAppMetadata', this.fdc3HandleGetAppMetadata.bind(this));\n\t        channel.register('fdc3v2GetInfo', async (payload, clientIdentity) => {\n\t            return this.fdc3HandleGetInfo.bind(this)(payload, clientIdentity);\n\t        });\n\t        channel.register('createPrivateChannelProvider', async (payload) => {\n\t            const { channelId } = payload;\n\t            const channelProvider = await this.fin.InterApplicationBus.Channel.create(channelId);\n\t            PrivateChannelProvider_1.PrivateChannelProvider.init(channelProvider, channelId);\n\t        });\n\t    }\n\t    /**\n\t     * Can be used to completely prevent a connection. Return false to prevent connections. Allows all connections by default.\n\t     * @param _id the identity tryinc to connect\n\t     * @param _connectionPayload optional payload to use in custom implementations, will be undefined by default\n\t     */\n\t    isConnectionAuthorized(_id, _connectionPayload) {\n\t        this.wire.sendAction('interop-broker-is-connection-authorized').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        return Promise.resolve(true);\n\t    }\n\t    /**\n\t     * Called before every action to check if this entity should be allowed to take the action.\n\t     * Return false to prevent the action\n\t     * @param _action the string action to authorize in camel case\n\t     * @param _payload the data being sent for this action\n\t     * @param _identity the connection attempting to dispatch this action\n\t     */\n\t    isActionAuthorized(_action, _payload, _identity) {\n\t        this.wire.sendAction('interop-broker-is-action-authorized').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        return Promise.resolve(true);\n\t    }\n\t};\n\tInteropBroker.InteropBroker = InteropBroker$1;\n\t_InteropBroker_fdc3Info = new WeakMap(), _InteropBroker_contextGroups = new WeakMap(), _InteropBroker_providerPromise = new WeakMap();\n\treturn InteropBroker;\n}\n\nvar InteropClient = {};\n\nvar SessionContextGroupClient$1 = {};\n\nvar __classPrivateFieldSet$2 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar __classPrivateFieldGet$2 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar _SessionContextGroupClient_clientPromise;\nObject.defineProperty(SessionContextGroupClient$1, \"__esModule\", { value: true });\nconst base_1$2 = base;\nconst utils_1$2 = utils$3;\nclass SessionContextGroupClient extends base_1$2.Base {\n    constructor(wire, client, id) {\n        super(wire);\n        _SessionContextGroupClient_clientPromise.set(this, void 0);\n        this.id = id;\n        __classPrivateFieldSet$2(this, _SessionContextGroupClient_clientPromise, client, \"f\");\n    }\n    /**\n     * Sets a context for the session context group.\n     * @param context - New context to set.\n     *\n     * @tutorial interop.setContext\n     */\n    async setContext(context) {\n        this.wire.sendAction('interop-session-context-group-set-context').catch((e) => {\n            // don't expose, analytics-only call\n        });\n        const client = await __classPrivateFieldGet$2(this, _SessionContextGroupClient_clientPromise, \"f\");\n        return client.dispatch(`sessionContextGroup:setContext-${this.id}`, {\n            sessionContextGroupId: this.id,\n            context\n        });\n    }\n    async getCurrentContext(type) {\n        this.wire.sendAction('interop-session-context-group-get-context').catch((e) => {\n            // don't expose, analytics-only call\n        });\n        const client = await __classPrivateFieldGet$2(this, _SessionContextGroupClient_clientPromise, \"f\");\n        return client.dispatch(`sessionContextGroup:getContext-${this.id}`, {\n            sessionContextGroupId: this.id,\n            type\n        });\n    }\n    async addContextHandler(contextHandler, contextType) {\n        this.wire.sendAction('interop-session-context-group-add-handler').catch((e) => {\n            // don't expose, analytics-only call\n        });\n        if (typeof contextHandler !== 'function') {\n            throw new Error(\"Non-function argument passed to the first parameter 'handler'. Be aware that the argument order does not match the FDC3 standard.\");\n        }\n        const client = await __classPrivateFieldGet$2(this, _SessionContextGroupClient_clientPromise, \"f\");\n        let handlerId;\n        if (contextType) {\n            handlerId = `sessionContextHandler:invoke-${this.id}-${contextType}-${(0, utils_1$2.generateId)()}`;\n        }\n        else {\n            handlerId = `sessionContextHandler:invoke-${this.id}`;\n        }\n        client.register(handlerId, (0, utils_1$2.wrapContextHandler)(contextHandler, handlerId));\n        await client.dispatch(`sessionContextGroup:handlerAdded-${this.id}`, { handlerId, contextType });\n        return { unsubscribe: await this.createUnsubscribeCb(handlerId) };\n    }\n    async createUnsubscribeCb(handlerId) {\n        const client = await __classPrivateFieldGet$2(this, _SessionContextGroupClient_clientPromise, \"f\");\n        return async () => {\n            client.remove(handlerId);\n            await client.dispatch(`sessionContextGroup:handlerRemoved-${this.id}`, { handlerId });\n        };\n    }\n    getUserInstance() {\n        return {\n            id: this.id,\n            setContext: (0, utils_1$2.wrapInTryCatch)(this.setContext.bind(this), 'Failed to set context: '),\n            getCurrentContext: (0, utils_1$2.wrapInTryCatch)(this.getCurrentContext.bind(this), 'Failed to get context: '),\n            addContextHandler: (0, utils_1$2.wrapInTryCatch)(this.addContextHandler.bind(this), 'Failed to add context handler: ')\n        };\n    }\n}\nSessionContextGroupClient$1.default = SessionContextGroupClient;\n_SessionContextGroupClient_clientPromise = new WeakMap();\n\nvar fdc31_2 = {};\n\nvar fdc3Common = {};\n\nvar utils$2 = {};\n\nvar PrivateChannelClient$1 = {};\n\nvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (commonjsGlobal && commonjsGlobal.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (commonjsGlobal && commonjsGlobal.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nObject.defineProperty(PrivateChannelClient$1, \"__esModule\", { value: true });\nPrivateChannelClient$1.PrivateChannelClient = void 0;\nconst utils$1 = __importStar(utils$3);\nclass PrivateChannelClient {\n    constructor(client, id) {\n        this.id = id;\n        this.client = client;\n        this.listeners = new Map();\n    }\n    async broadcast(context) {\n        return this.client.dispatch('broadcast', { context });\n    }\n    async getCurrentContext(contextType) {\n        return this.client.dispatch('getCurrentContext', { contextType });\n    }\n    async addContextListener(contextType, handler) {\n        if (typeof handler !== 'function') {\n            throw new Error(\"Non-function argument passed to the second parameter 'handler'. Be aware that the argument order does not match the FDC3 standard.\");\n        }\n        let handlerId;\n        if (contextType) {\n            handlerId = `contextHandler:invoke-${this.id}-${contextType}-${utils$1.generateId()}`;\n        }\n        else {\n            handlerId = `contextHandler:invoke-${this.id}-${utils$1.generateId()}`;\n        }\n        this.client.register(handlerId, utils$1.wrapContextHandler(handler, handlerId));\n        const listener = { unsubscribe: await this.createContextUnsubscribeCb(handlerId) };\n        this.listeners.set(handlerId, listener);\n        await this.client.dispatch(`contextHandlerAdded`, { handlerId, contextType });\n        return listener;\n    }\n    createNonStandardUnsubscribeCb(handlerId) {\n        return async () => {\n            this.client.remove(handlerId);\n            this.listeners.delete(handlerId);\n            await this.client.dispatch('nonStandardHandlerRemoved', { handlerId });\n        };\n    }\n    createContextUnsubscribeCb(handlerId) {\n        return async () => {\n            this.client.remove(handlerId);\n            this.listeners.delete(handlerId);\n            await this.client.dispatch('contextHandlerRemoved', { handlerId });\n        };\n    }\n    onAddContextListener(handler) {\n        const handlerId = `onContextHandlerAdded:invoke-${this.id}-${utils$1.generateId()}`;\n        this.client.register(handlerId, handler);\n        const listener = { unsubscribe: this.createNonStandardUnsubscribeCb(handlerId) };\n        this.listeners.set(handlerId, listener);\n        this.client.dispatch(`onAddContextHandlerAdded`, { handlerId });\n        return listener;\n    }\n    onDisconnect(handler) {\n        const handlerId = `onDisconnect:invoke-${this.id}-${utils$1.generateId()}`;\n        this.client.register(handlerId, handler);\n        const listener = { unsubscribe: this.createNonStandardUnsubscribeCb(handlerId) };\n        this.listeners.set(handlerId, listener);\n        this.client.dispatch(`onDisconnectHandlerAdded`, { handlerId });\n        return listener;\n    }\n    onUnsubscribe(handler) {\n        const handlerId = `onUnsubscribe:invoke-${this.id}-${utils$1.generateId()}`;\n        this.client.register(handlerId, handler);\n        const listener = { unsubscribe: this.createNonStandardUnsubscribeCb(handlerId) };\n        this.listeners.set(handlerId, listener);\n        this.client.dispatch(`onUnsubscribeHandlerAdded`, { handlerId });\n        return listener;\n    }\n    async cleanUpAllSubs() {\n        const listenerUnsubscribers = Array.from(this.listeners.keys());\n        listenerUnsubscribers.forEach((handlerId) => {\n            this.client.remove(handlerId);\n            this.listeners.delete(handlerId);\n        });\n    }\n    async disconnect() {\n        try {\n            await this.client.dispatch('clientDisconnecting');\n            await this.cleanUpAllSubs();\n            await this.client.disconnect();\n        }\n        catch (error) {\n            throw new Error(error.message);\n        }\n    }\n}\nPrivateChannelClient$1.PrivateChannelClient = PrivateChannelClient;\n\n(function (exports) {\n\tvar __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {\n\t    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n\t};\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\texports.getIntentResolution = exports.isChannel = exports.isContext = exports.connectPrivateChannel = exports.buildAppChannelObject = exports.buildPrivateChannelObject = exports.ChannelError = exports.ResultError = exports.UnsupportedChannelApiError = exports.getUnsupportedChannelApis = void 0;\n\tconst utils_1 = utils$3;\n\tconst PrivateChannelClient_1 = PrivateChannelClient$1;\n\tconst isEqual_1 = __importDefault(require$$3);\n\tconst getUnsupportedChannelApis = (channelType) => {\n\t    return {\n\t        addContextListener: () => {\n\t            throw new UnsupportedChannelApiError('Channel.addContextListener', channelType);\n\t        },\n\t        broadcast: () => {\n\t            throw new UnsupportedChannelApiError('Channel.broadcast', channelType);\n\t        },\n\t        getCurrentContext: () => {\n\t            throw new UnsupportedChannelApiError('Channel.getCurrentContext', channelType);\n\t        }\n\t    };\n\t};\n\texports.getUnsupportedChannelApis = getUnsupportedChannelApis;\n\tclass UnsupportedChannelApiError extends Error {\n\t    constructor(apiName, channelType = 'System') {\n\t        super(apiName);\n\t        this.message = `Calling ${apiName} on an instance of a ${channelType} Channel returned by fdc3.get${channelType}Channels is not supported. If you would like to use a ${channelType} Channel, please use fdc3.joinChannel, fdc3.addContextListener, and fdc3.broadcast instead.`;\n\t    }\n\t}\n\texports.UnsupportedChannelApiError = UnsupportedChannelApiError;\n\tvar ResultError;\n\t(function (ResultError) {\n\t    /** Returned if the `IntentHandler` exited without returning a Promise or that\n\t     *  Promise was not resolved with a Context or Channel object.\n\t     */\n\t    ResultError[\"NoResultReturned\"] = \"NoResultReturned\";\n\t    /** Returned if the `IntentHandler` function processing the raised intent\n\t     *  throws an error or rejects the Promise it returned.\n\t     */\n\t    ResultError[\"IntentHandlerRejected\"] = \"IntentHandlerRejected\";\n\t})(ResultError = exports.ResultError || (exports.ResultError = {}));\n\t(function (ChannelError) {\n\t    /** Returned if the specified channel is not found when attempting to join a\n\t     *  channel via the `joinUserChannel` function of the DesktopAgent (`fdc3`).\n\t     */\n\t    ChannelError[\"NoChannelFound\"] = \"NoChannelFound\";\n\t    /** SHOULD be returned when a request to join a user channel or to a retrieve\n\t     *  a Channel object via the `joinUserChannel` or `getOrCreateChannel` methods\n\t     *  of the DesktopAgent (`fdc3`) object is denied.\n\t     */\n\t    ChannelError[\"AccessDenied\"] = \"AccessDenied\";\n\t    /** SHOULD be returned when a channel cannot be created or retrieved via the\n\t     *  `getOrCreateChannel` method of the DesktopAgent (`fdc3`).\n\t     */\n\t    ChannelError[\"CreationFailed\"] = \"CreationFailed\";\n\t})(exports.ChannelError || (exports.ChannelError = {}));\n\tconst buildPrivateChannelObject = (privateChannelClient) => {\n\t    let clientDisconnected = false;\n\t    const checkIfClientDisconnected = () => {\n\t        if (clientDisconnected) {\n\t            throw new Error('Private Channel Client has been disconnected from the Private Channel');\n\t        }\n\t    };\n\t    return {\n\t        id: privateChannelClient.id,\n\t        type: 'private',\n\t        broadcast: async (context) => {\n\t            checkIfClientDisconnected();\n\t            return privateChannelClient.broadcast(context);\n\t        },\n\t        getCurrentContext: async (contextType) => {\n\t            checkIfClientDisconnected();\n\t            return privateChannelClient.getCurrentContext(contextType);\n\t        },\n\t        // @ts-expect-error TODO [CORE-1524]\n\t        addContextListener: async (contextType, handler) => {\n\t            checkIfClientDisconnected();\n\t            let handlerInUse = handler;\n\t            let contextTypeInUse = contextType;\n\t            if (typeof contextType === 'function') {\n\t                console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');\n\t                handlerInUse = contextType;\n\t                contextTypeInUse = null;\n\t            }\n\t            const listener = privateChannelClient.addContextListener(contextTypeInUse, handlerInUse);\n\t            return listener;\n\t        },\n\t        onAddContextListener: (handler) => {\n\t            checkIfClientDisconnected();\n\t            return privateChannelClient.onAddContextListener(handler);\n\t        },\n\t        disconnect: async () => {\n\t            checkIfClientDisconnected();\n\t            clientDisconnected = true;\n\t            return privateChannelClient.disconnect();\n\t        },\n\t        onDisconnect: (handler) => {\n\t            checkIfClientDisconnected();\n\t            return privateChannelClient.onDisconnect(handler);\n\t        },\n\t        onUnsubscribe: (handler) => {\n\t            checkIfClientDisconnected();\n\t            return privateChannelClient.onUnsubscribe(handler);\n\t        }\n\t    };\n\t};\n\texports.buildPrivateChannelObject = buildPrivateChannelObject;\n\tconst buildAppChannelObject = (sessionContextGroup) => {\n\t    return {\n\t        id: sessionContextGroup.id,\n\t        type: 'app',\n\t        broadcast: sessionContextGroup.setContext,\n\t        getCurrentContext: async (contextType) => {\n\t            const context = await sessionContextGroup.getCurrentContext(contextType);\n\t            return context === undefined ? null : context;\n\t        },\n\t        // @ts-expect-error TODO [CORE-1524]\n\t        addContextListener: (contextType, handler) => {\n\t            let realHandler;\n\t            let realType;\n\t            if (typeof contextType === 'function') {\n\t                console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');\n\t                realHandler = contextType;\n\t            }\n\t            else {\n\t                realHandler = handler;\n\t                if (typeof contextType === 'string') {\n\t                    realType = contextType;\n\t                }\n\t            }\n\t            const listener = (async () => {\n\t                let first = true;\n\t                const currentContext = await sessionContextGroup.getCurrentContext(realType);\n\t                const wrappedHandler = (context, contextMetadata) => {\n\t                    if (first) {\n\t                        first = false;\n\t                        if ((0, isEqual_1.default)(currentContext, context)) {\n\t                            return;\n\t                        }\n\t                    }\n\t                    // eslint-disable-next-line consistent-return\n\t                    return realHandler(context, contextMetadata);\n\t                };\n\t                return sessionContextGroup.addContextHandler(wrappedHandler, realType);\n\t            })();\n\t            return {\n\t                ...listener,\n\t                unsubscribe: () => listener.then((l) => l.unsubscribe())\n\t            };\n\t        }\n\t    };\n\t};\n\texports.buildAppChannelObject = buildAppChannelObject;\n\tconst connectPrivateChannel = async (channelId) => {\n\t    try {\n\t        const channelClient = await fin.InterApplicationBus.Channel.connect(channelId);\n\t        const privateChannelClient = new PrivateChannelClient_1.PrivateChannelClient(channelClient, channelId);\n\t        return (0, exports.buildPrivateChannelObject)(privateChannelClient);\n\t    }\n\t    catch (error) {\n\t        throw new Error(`Private Channel with id: ${channelId} doesn't exist`);\n\t    }\n\t};\n\texports.connectPrivateChannel = connectPrivateChannel;\n\tconst isContext = (context) => {\n\t    if (context && typeof context === 'object' && 'type' in context) {\n\t        const { type } = context;\n\t        return typeof type === 'string';\n\t    }\n\t    return false;\n\t};\n\texports.isContext = isContext;\n\tconst isChannel = (channel) => {\n\t    if (channel && typeof channel === 'object' && 'type' in channel && 'id' in channel) {\n\t        const { type, id } = channel;\n\t        return typeof type === 'string' && typeof id === 'string' && (type === 'app' || type === 'private');\n\t    }\n\t    return false;\n\t};\n\texports.isChannel = isChannel;\n\tconst getIntentResolution = async (interopModule, context, app, intent) => {\n\t    // Generate an ID to make a session context group with. We will pass that ID to the Broker.\n\t    // The broker will then setContext on that session context group later with our Intent Result,\n\t    const guid = (0, utils_1.generateId)(); // TODO make this undefined in web\n\t    // Promise we'll use in getResult\n\t    const getResultPromise = new Promise((resolve, reject) => {\n\t        fin.InterApplicationBus.subscribe({ uuid: '*' }, guid, (intentResult) => {\n\t            resolve(intentResult);\n\t        }).catch(() => reject(new Error('getResult is not supported in this environment')));\n\t    });\n\t    // Adding the intentResolutionResultId to the intentObj. Because fireIntent only accepts a single arg, we have to slap it in here.\n\t    const metadata = app ? { target: app, intentResolutionResultId: guid } : { intentResolutionResultId: guid };\n\t    const intentObj = intent ? { name: intent, context, metadata } : { ...context, metadata };\n\t    // Set up the getResult call.\n\t    const getResult = async () => {\n\t        let intentResult = await getResultPromise;\n\t        if (!intentResult || typeof intentResult !== 'object') {\n\t            throw new Error(ResultError.NoResultReturned);\n\t        }\n\t        const { error } = intentResult;\n\t        if (error) {\n\t            throw new Error(ResultError.IntentHandlerRejected);\n\t        }\n\t        if ((0, exports.isChannel)(intentResult)) {\n\t            const { id, type } = intentResult;\n\t            switch (type) {\n\t                case 'private': {\n\t                    intentResult = await (0, exports.connectPrivateChannel)(id);\n\t                    break;\n\t                }\n\t                case 'app': {\n\t                    const sessionContextGroup = await interopModule.joinSessionContextGroup(id);\n\t                    intentResult = (0, exports.buildAppChannelObject)(sessionContextGroup);\n\t                    break;\n\t                }\n\t            }\n\t        }\n\t        else if (!(0, exports.isContext)(intentResult)) {\n\t            throw new Error(ResultError.NoResultReturned);\n\t        }\n\t        return intentResult;\n\t    };\n\t    // Finally fire the intent.\n\t    const intentResolutionInfoFromBroker = intent\n\t        ? await interopModule.fireIntent(intentObj)\n\t        : await interopModule.fireIntentForContext(intentObj);\n\t    if (typeof intentResolutionInfoFromBroker !== 'object') {\n\t        return {\n\t            source: {\n\t                appId: '',\n\t                instanceId: ''\n\t            },\n\t            intent: '',\n\t            version: '2.0',\n\t            getResult\n\t        };\n\t    }\n\t    return { ...intentResolutionInfoFromBroker, getResult };\n\t};\n\texports.getIntentResolution = getIntentResolution; \n} (utils$2));\n\nvar hasRequiredFdc3Common;\n\nfunction requireFdc3Common () {\n\tif (hasRequiredFdc3Common) return fdc3Common;\n\thasRequiredFdc3Common = 1;\n\tvar __classPrivateFieldGet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n\t    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n\t    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n\t    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n\t};\n\tvar __classPrivateFieldSet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n\t    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n\t    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n\t    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n\t    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n\t};\n\tvar __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {\n\t    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n\t};\n\tvar _FDC3ModuleBase_producer;\n\tObject.defineProperty(fdc3Common, \"__esModule\", { value: true });\n\tfdc3Common.FDC3ModuleBase = void 0;\n\tconst utils_1 = utils$2;\n\tconst utils_2 = utils$3;\n\tconst InteropClient_1 = requireInteropClient();\n\tconst isEqual_1 = __importDefault(require$$3);\n\tclass FDC3ModuleBase {\n\t    get client() {\n\t        return __classPrivateFieldGet(this, _FDC3ModuleBase_producer, \"f\").call(this);\n\t    }\n\t    get fin() {\n\t        return this.wire.getFin();\n\t    }\n\t    // eslint-disable-next-line no-useless-constructor\n\t    constructor(producer, wire) {\n\t        this.wire = wire;\n\t        _FDC3ModuleBase_producer.set(this, void 0);\n\t        __classPrivateFieldSet(this, _FDC3ModuleBase_producer, producer, \"f\");\n\t    }\n\t    /**\n\t     * Broadcasts a context for the channel of the current entity.\n\t     * @param context - New context to set.\n\t     *\n\t     * @tutorial fdc3.broadcast\n\t     * @static\n\t     */\n\t    async broadcast(context) {\n\t        this.wire.sendAction('fdc3-broadcast').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return this.client.setContext(context);\n\t    }\n\t    /**\n\t     * Launches an app with target information, which can either be a string or an AppMetadata object.\n\t     * @param app\n\t     * @param context\n\t     *\n\t     * @tutorial fdc3.open\n\t     */\n\t    async _open(app, context) {\n\t        this.wire.sendAction('fdc3-open').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        try {\n\t            return await InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'fdc3Open', { app, context });\n\t        }\n\t        catch (error) {\n\t            const errorToThrow = error.message === utils_2.BROKER_ERRORS.fdc3Open ? 'ResolverUnavailable' : error.message;\n\t            throw new Error(errorToThrow);\n\t        }\n\t    }\n\t    async _getChannels() {\n\t        const channels = await this.client.getContextGroups();\n\t        // fdc3 implementation of getSystemChannels returns an array of channels, have to decorate over\n\t        // this so people know that these APIs are not supported\n\t        return channels.map((channel) => {\n\t            return { ...channel, type: 'system', ...(0, utils_1.getUnsupportedChannelApis)() };\n\t        });\n\t    }\n\t    /**\n\t     * Returns a Channel object for the specified channel, creating it as an App Channel if it does not exist.\n\t     * @param channelId\n\t     *\n\t     * @tutorial fdc3.getOrCreateChannel\n\t     */\n\t    async getOrCreateChannel(channelId) {\n\t        this.wire.sendAction('fdc3-get-or-create-channel').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const systemChannels = await this._getChannels();\n\t        const userChannel = systemChannels.find((channel) => channel.id === channelId);\n\t        if (userChannel) {\n\t            return { ...userChannel, type: 'system', ...(0, utils_1.getUnsupportedChannelApis)() };\n\t        }\n\t        try {\n\t            const sessionContextGroup = await this.client.joinSessionContextGroup(channelId);\n\t            return (0, utils_1.buildAppChannelObject)(sessionContextGroup);\n\t        }\n\t        catch (error) {\n\t            console.error(error.message);\n\t            throw new Error(utils_1.ChannelError.CreationFailed);\n\t        }\n\t    }\n\t    /**\n\t     * Returns the Interop-Broker-defined context groups available for an entity to join.\n\t     *\n\t     * @tutorial fdc3.getSystemChannels\n\t     * @static\n\t     */\n\t    async getSystemChannels() {\n\t        this.wire.sendAction('fdc3-get-system-channels').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return this._getChannels();\n\t    }\n\t    /**\n\t     * Join all Interop Clients at the given identity to context group `contextGroupId`.\n\t     * If no target is specified, it adds the sender to the context group.\n\t     * Because multiple Channel connections/Interop Clients can potentially exist at a `uuid`/`name` combo, we currently join all Channel connections/Interop Clients at the given identity to the context group.\n\t     * If an `endpointId` is provided (which is unlikely, unless the call is coming from an external adapter), then we only join that single connection to the context group.\n\t     * For all intents and purposes, there will only be 1 connection present in Platform and Browser implementations, so this point is more-or-less moot.\n\t     * @param channelId - Id of the context group.\n\t     *\n\t     * @tutorial fdc3.joinChannel\n\t     * @static\n\t     */\n\t    async joinChannel(channelId) {\n\t        this.wire.sendAction('fdc3-join-channel').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        try {\n\t            return await this.client.joinContextGroup(channelId);\n\t        }\n\t        catch (error) {\n\t            if (error.message === utils_2.BROKER_ERRORS.joinSessionContextGroupWithJoinContextGroup) {\n\t                console.error('The Channel you have tried to join is an App Channel. Custom Channels can only be defined by the Interop Broker through code or manifest configuration. Please use getOrCreateChannel.');\n\t            }\n\t            else {\n\t                console.error(error.message);\n\t            }\n\t            if (error.message.startsWith('Attempting to join a context group that does not exist')) {\n\t                throw new Error(utils_1.ChannelError.NoChannelFound);\n\t            }\n\t            throw new Error(utils_1.ChannelError.AccessDenied);\n\t        }\n\t    }\n\t    /**\n\t     * Returns the Channel that the entity is subscribed to. Returns null if not joined to a channel.\n\t     *\n\t     * @tutorial fdc3.getCurrentChannel\n\t     */\n\t    async getCurrentChannel() {\n\t        this.wire.sendAction('fdc3-get-current-channel').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const currentContextGroupInfo = await this.getCurrentContextGroupInfo();\n\t        if (!currentContextGroupInfo) {\n\t            return null;\n\t        }\n\t        return this.buildChannelObject(currentContextGroupInfo);\n\t    }\n\t    /**\n\t     * Removes the specified target from a context group.\n\t     * If no target is specified, it removes the sender from their context group.\n\t     *\n\t     * @tutorial fdc3.leaveCurrentChannel\n\t     * @static\n\t     */\n\t    async leaveCurrentChannel() {\n\t        this.wire.sendAction('fdc3-leave-current-channel').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return this.client.removeFromContextGroup();\n\t    }\n\t    // utils\n\t    // eslint-disable-next-line class-methods-use-this\n\t    async getCurrentContextGroupInfo() {\n\t        const contextGroups = await this.client.getContextGroups();\n\t        const clientsInCtxGroupsPromise = contextGroups.map(async (ctxGroup) => {\n\t            return this.client.getAllClientsInContextGroup(ctxGroup.id);\n\t        });\n\t        const clientsInCtxGroups = await Promise.all(clientsInCtxGroupsPromise);\n\t        const clientIdx = clientsInCtxGroups.findIndex((clientIdentityArr) => {\n\t            return clientIdentityArr.some((clientIdentity) => {\n\t                const { uuid, name } = clientIdentity;\n\t                return this.wire.me.uuid === uuid && this.wire.me.name === name;\n\t            });\n\t        });\n\t        return contextGroups[clientIdx];\n\t    }\n\t    async buildChannelObject(currentContextGroupInfo) {\n\t        // @ts-expect-error\n\t        return {\n\t            ...currentContextGroupInfo,\n\t            type: 'system',\n\t            addContextListener: (...[contextType, handler]) => {\n\t                let realHandler;\n\t                let realType;\n\t                if (typeof contextType === 'function') {\n\t                    console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');\n\t                    realHandler = contextType;\n\t                }\n\t                else {\n\t                    realHandler = handler;\n\t                    if (typeof contextType === 'string') {\n\t                        realType = contextType;\n\t                    }\n\t                }\n\t                const listener = (async () => {\n\t                    let first = true;\n\t                    const currentContext = await this.client.getCurrentContext(realType);\n\t                    const wrappedHandler = (context, contextMetadata) => {\n\t                        if (first) {\n\t                            first = false;\n\t                            if ((0, isEqual_1.default)(currentContext, context)) {\n\t                                return;\n\t                            }\n\t                        }\n\t                        // eslint-disable-next-line consistent-return\n\t                        return realHandler(context, contextMetadata);\n\t                    };\n\t                    return this.client.addContextHandler(wrappedHandler, realType);\n\t                })();\n\t                // @ts-expect-error TODO [CORE-1524]\n\t                return {\n\t                    ...listener,\n\t                    unsubscribe: () => listener.then((l) => l.unsubscribe())\n\t                };\n\t            },\n\t            broadcast: this.broadcast.bind(this),\n\t            // @ts-expect-error Typescript fails to infer the returntype is a Promise\n\t            getCurrentContext: async (contextType) => {\n\t                const context = await this.client.getCurrentContext(contextType);\n\t                // @ts-expect-error Typescript fails to infer the returntype is a Promise\n\t                return context === undefined ? null : context;\n\t            }\n\t        };\n\t    }\n\t}\n\tfdc3Common.FDC3ModuleBase = FDC3ModuleBase;\n\t_FDC3ModuleBase_producer = new WeakMap();\n\treturn fdc3Common;\n}\n\nvar hasRequiredFdc31_2;\n\nfunction requireFdc31_2 () {\n\tif (hasRequiredFdc31_2) return fdc31_2;\n\thasRequiredFdc31_2 = 1;\n\tObject.defineProperty(fdc31_2, \"__esModule\", { value: true });\n\tfdc31_2.Fdc3Module = void 0;\n\tconst utils_1 = utils$3;\n\tconst fdc3_common_1 = requireFdc3Common();\n\t/**\n\t * @version 1.2\n\t * The FDC3 Client Library provides a set APIs to be used for FDC3 compliance,\n\t * while using our Interop API under the hood. In order to use this set of APIs\n\t * you will need to set up your own {@link InteropBroker InteropBroker} or use a Platform application, which does the setup for you. Refer to our documentation on\n\t * our {@link https://developers.openfin.co/of-docs/docs/enable-color-linking Interop API}.\n\t *\n\t * To enable the FDC3 APIs in a {@link Window Window} or {@link View View}, add the fdc3InteropApi\n\t * property to its options:\n\t *\n\t * ```js\n\t * {\n\t *     autoShow: false,\n\t *     saveWindowState: true,\n\t *     url: 'https://openfin.co',\n\t *     fdc3InteropApi: '1.2'\n\t * }\n\t * ```\n\t *\n\t * If using a {@link Platform Platform } application, you can set this property in defaultWindowOptions and defaultViewOptions.\n\t *\n\t * In order to ensure that the FDC3 Api is ready before use, you can use the 'fdc3Ready' event fired on the DOM Window object:\n\t *\n\t * ```js\n\t * function fdc3Action() {\n\t *     // Make some fdc3 API calls here\n\t * }\n\t *\n\t * if (window.fdc3) {\n\t *    fdc3Action();\n\t * } else {\n\t *    window.addEventListener('fdc3Ready', fdc3Action);\n\t * }\n\t * ```\n\t */\n\tclass Fdc3Module extends fdc3_common_1.FDC3ModuleBase {\n\t    async open(app, context) {\n\t        // eslint-disable-next-line no-underscore-dangle\n\t        await super._open(app, context);\n\t    }\n\t    /**\n\t     * Add a context handler for incoming context. If an entity is part of a context group, and then sets its context handler, it will receive all of its declared contexts. If you wish to listen for all incoming contexts, pass `null` for the contextType argument.\n\t     * @param contextType - The type of context you wish to handle.\n\t     * @param handler - Handler for incoming context.\n\t     *\n\t     * @tutorial fdc3.addContextListener\n\t     * @static\n\t     */\n\t    // @ts-expect-error TODO [CORE-1524]\n\t    addContextListener(contextType, handler) {\n\t        this.wire.sendAction('fdc3-add-context-listener').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        let listener;\n\t        if (typeof contextType === 'function') {\n\t            console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');\n\t            listener = this.client.addContextHandler(contextType);\n\t        }\n\t        else {\n\t            listener = this.client.addContextHandler(handler, contextType === null ? undefined : contextType);\n\t        }\n\t        return {\n\t            ...listener,\n\t            unsubscribe: () => listener.then((l) => l.unsubscribe())\n\t        };\n\t    }\n\t    /**\n\t     * Adds a listener for incoming Intents.\n\t     * @param intent - Name of the Intent\n\t     * @param handler - Handler for incoming Intent\n\t     *\n\t     * @tutorial fdc3.addIntentListener\n\t     * @static\n\t     */\n\t    addIntentListener(intent, handler) {\n\t        this.wire.sendAction('fdc3-add-intent-listener').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const contextHandler = (raisedIntent) => {\n\t            const { context, metadata: intentMetadata } = raisedIntent;\n\t            const { metadata } = context;\n\t            const intentResolutionResultId = intentMetadata?.intentResolutionResultId || metadata?.intentResolutionResultId;\n\t            if (intentResolutionResultId) {\n\t                this.fin.InterApplicationBus.publish(intentResolutionResultId, null).catch(() => null);\n\t            }\n\t            handler(raisedIntent.context);\n\t        };\n\t        const listener = this.client.registerIntentHandler(contextHandler, intent, {\n\t            fdc3Version: '1.2'\n\t        });\n\t        return {\n\t            ...listener,\n\t            unsubscribe: () => listener.then((l) => l.unsubscribe())\n\t        };\n\t    }\n\t    /**\n\t     * Raises a specific intent.\n\t     * @param intent Name of the Intent.\n\t     * @param context Context associated with the Intent.\n\t     * @param  app App that will resolve the Intent. This is added as metadata to the Intent. Can be accessed by the app provider in {@link InteropBroker#handleFiredIntent InteropBroker.handleFiredIntent}.\n\t     *\n\t     * @tutorial fdc3.raiseIntent\n\t     * @static\n\t     */\n\t    async raiseIntent(intent, context, app) {\n\t        this.wire.sendAction('fdc3-raise-intent').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const intentObj = app\n\t            ? { name: intent, context, metadata: { target: app } }\n\t            : { name: intent, context };\n\t        try {\n\t            return await this.client.fireIntent(intentObj);\n\t        }\n\t        catch (error) {\n\t            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fireIntent ? 'ResolverUnavailable' : error.message;\n\t            throw new Error(errorToThrow);\n\t        }\n\t    }\n\t    /**\n\t     * Find out more information about a particular intent by passing its name, and optionally its context.\n\t     * @param intent Name of the Intent\n\t     * @param context\n\t     *\n\t     * @tutorial fdc3.findIntent\n\t     */\n\t    async findIntent(intent, context) {\n\t        this.wire.sendAction('fdc3-find-intent').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        try {\n\t            return await this.client.getInfoForIntent({ name: intent, context });\n\t        }\n\t        catch (error) {\n\t            const errorToThrow = error.message === utils_1.BROKER_ERRORS.getInfoForIntent ? 'ResolverUnavailable' : error.message;\n\t            throw new Error(errorToThrow);\n\t        }\n\t    }\n\t    /**\n\t     * Find all the available intents for a particular context.\n\t     * @param context\n\t     *\n\t     * @tutorial fdc3.findIntentsByContext\n\t     */\n\t    async findIntentsByContext(context) {\n\t        this.wire.sendAction('fdc3-find-intents-by-context').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        try {\n\t            return await this.client.getInfoForIntentsByContext(context);\n\t        }\n\t        catch (error) {\n\t            const errorToThrow = error.message === utils_1.BROKER_ERRORS.getInfoForIntentsByContext ? 'ResolverUnavailable' : error.message;\n\t            throw new Error(errorToThrow);\n\t        }\n\t    }\n\t    /**\n\t     * Finds and raises an intent against a target app based purely on context data.\n\t     * @param context\n\t     * @param app\n\t     *\n\t     * @tutorial fdc3.raiseIntentForContext\n\t     */\n\t    async raiseIntentForContext(context, app) {\n\t        this.wire.sendAction('fdc3-raise-intent-for-context').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        try {\n\t            return await this.client.fireIntentForContext({ ...context, metadata: { target: app } });\n\t        }\n\t        catch (error) {\n\t            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fireIntentForContext ? 'ResolverUnavailable' : error.message;\n\t            throw new Error(errorToThrow);\n\t        }\n\t    }\n\t    /**\n\t     * Returns a Channel object for the specified channel, creating it as an App Channel if it does not exist.\n\t     * @param channelId\n\t     *\n\t     * @tutorial fdc3.getOrCreateChannel\n\t     */\n\t    async getOrCreateChannel(channelId) {\n\t        return super.getOrCreateChannel(channelId);\n\t    }\n\t    /**\n\t     * Returns metadata relating to the FDC3 object and its provider, including the supported version of the FDC3 specification and the name of the provider of the implementation.\n\t     *\n\t     * @tutorial fdc3.getInfo\n\t     */\n\t    getInfo() {\n\t        this.wire.sendAction('fdc3-get-info').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const version = this.wire.environment.getAdapterVersionSync();\n\t        return {\n\t            providerVersion: version,\n\t            provider: `openfin-${this.wire.me.uuid}`,\n\t            fdc3Version: '1.2'\n\t        };\n\t    }\n\t}\n\tfdc31_2.Fdc3Module = Fdc3Module;\n\treturn fdc31_2;\n}\n\nvar fdc32_0 = {};\n\nvar hasRequiredFdc32_0;\n\nfunction requireFdc32_0 () {\n\tif (hasRequiredFdc32_0) return fdc32_0;\n\thasRequiredFdc32_0 = 1;\n\tObject.defineProperty(fdc32_0, \"__esModule\", { value: true });\n\tfdc32_0.Fdc3Module2 = void 0;\n\tconst fdc3_common_1 = requireFdc3Common();\n\tconst utils_1 = utils$3;\n\tconst InteropClient_1 = requireInteropClient();\n\tconst utils_2 = utils$2;\n\tconst PrivateChannelClient_1 = PrivateChannelClient$1;\n\t/**\n\t * @version 2.0\n\t * The FDC3 Client Library provides a set APIs to be used for FDC3 compliance,\n\t * while using our Interop API under the hood. In order to use this set of APIs\n\t * you will need to set up your own {@link InteropBroker InteropBroker} or use a Platform application, which does the setup for you. Refer to our documentation on\n\t * our {@link https://developers.openfin.co/of-docs/docs/enable-context-sharing Interop API}.\n\t *\n\t * To enable the FDC3 APIs in a {@link Window Window} or {@link View View}, add the fdc3InteropApi\n\t * property to its options:\n\t *\n\t * ```js\n\t * {\n\t *     autoShow: false,\n\t *     saveWindowState: true,\n\t *     url: 'https://openfin.co',\n\t *     fdc3InteropApi: '2.0'\n\t * }\n\t * ```\n\t *\n\t * If using a {@link Platform Platform } application, you can set this property in defaultWindowOptions and defaultViewOptions.\n\t *\n\t * In order to ensure that the FDC3 Api is ready before use, you can use the 'fdc3Ready' event fired on the DOM Window object:\n\t *\n\t * ```js\n\t * function fdc3Action() {\n\t *     // Make some fdc3 API calls here\n\t * }\n\t *\n\t * if (window.fdc3) {\n\t *    fdc3Action();\n\t * } else {\n\t *    window.addEventListener('fdc3Ready', fdc3Action);\n\t * }\n\t * ```\n\t */\n\tclass Fdc3Module2 extends fdc3_common_1.FDC3ModuleBase {\n\t    /**\n\t     * Launches an app, specified via an AppIdentifier object.\n\t     * @param app\n\t     * @param context\n\t     *\n\t     * @tutorial fdc3.open\n\t     */\n\t    async open(app, context) {\n\t        if (typeof app === 'string') {\n\t            console.warn('Passing a string as the app parameter is deprecated, please use an AppIdentifier ({ appId: string; instanceId?: string }).');\n\t        }\n\t        // eslint-disable-next-line no-underscore-dangle\n\t        return super._open(app, context);\n\t    }\n\t    /**\n\t     * Find all the available instances for a particular application.\n\t     * @param app\n\t     *\n\t     * @tutorial fdc3v2.findInstances\n\t     */\n\t    async findInstances(app) {\n\t        this.wire.sendAction('fdc3-find-instances').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        try {\n\t            return await InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'fdc3FindInstances', app);\n\t        }\n\t        catch (error) {\n\t            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fdc3FindInstances ? 'ResolverUnavailable' : error.message;\n\t            throw new Error(errorToThrow);\n\t        }\n\t    }\n\t    /**\n\t     * Retrieves the AppMetadata for an AppIdentifier, which provides additional metadata (such as icons, a title and description) from the App Directory record for the application, that may be used for display purposes.\n\t     * @param app\n\t     *\n\t     * @tutorial fdc3v2.getAppMetadata\n\t     */\n\t    async getAppMetadata(app) {\n\t        this.wire.sendAction('fdc3-get-app-metadata').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        try {\n\t            return await InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'fdc3GetAppMetadata', app);\n\t        }\n\t        catch (error) {\n\t            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fdc3GetAppMetadata ? 'ResolverUnavailable' : error.message;\n\t            throw new Error(errorToThrow);\n\t        }\n\t    }\n\t    /**\n\t     * Add a context handler for incoming context. If an entity is part of a context group, and then sets its context handler, it will receive all of its declared contexts. If you wish to listen for all incoming contexts, pass `null` for the contextType argument.\n\t     * @param contextType\n\t     * @param handler\n\t     *\n\t     * @tutorial fdc3.addContextListener\n\t     */\n\t    // @ts-expect-error TODO [CORE-1524]\n\t    async addContextListener(contextType, handler) {\n\t        this.wire.sendAction('fdc3-add-context-listener').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        // The FDC3 ContextHandler only expects the context and optional ContextMetadata, so we wrap the handler\n\t        // here so it only gets passed these parameters\n\t        const getWrappedHandler = (handlerToWrap) => {\n\t            return (context) => {\n\t                const { contextMetadata, ...rest } = context;\n\t                const args = contextMetadata ? [{ ...rest }, contextMetadata] : [context, null];\n\t                handlerToWrap(...args);\n\t            };\n\t        };\n\t        let actualHandler = handler;\n\t        let wrappedHandler = getWrappedHandler(actualHandler);\n\t        if (typeof contextType === 'function') {\n\t            console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');\n\t            actualHandler = contextType;\n\t            wrappedHandler = getWrappedHandler(actualHandler);\n\t            return this.client.addContextHandler(wrappedHandler);\n\t        }\n\t        return this.client.addContextHandler(wrappedHandler, contextType === null ? undefined : contextType);\n\t    }\n\t    /**\n\t     * Find out more information about a particular intent by passing its name, and optionally its context and resultType.\n\t     * @param intent Name of the Intent\n\t     * @param context Context\n\t     * @param resultType The type of result returned for any intent specified during resolution.\n\t     *\n\t     * @tutorial fdc3.findIntent\n\t     */\n\t    async findIntent(intent, context, resultType) {\n\t        this.wire.sendAction('fdc3-find-intent').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        try {\n\t            return await this.client.getInfoForIntent({ name: intent, context, metadata: { resultType } });\n\t        }\n\t        catch (error) {\n\t            const errorToThrow = error.message === utils_1.BROKER_ERRORS.getInfoForIntent ? 'ResolverUnavailable' : error.message;\n\t            throw new Error(errorToThrow);\n\t        }\n\t    }\n\t    /**\n\t     * Find all the available intents for a particular context.\n\t     * @param context\n\t     * @param resultType The type of result returned for any intent specified during resolution.\n\t     *\n\t     * @tutorial fdc3v2.findIntentsByContext\n\t     */\n\t    async findIntentsByContext(context, resultType) {\n\t        this.wire.sendAction('fdc3-find-intents-by-context').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const payload = resultType ? { context, metadata: { resultType } } : context;\n\t        try {\n\t            return await InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'fdc3v2FindIntentsByContext', payload);\n\t        }\n\t        catch (error) {\n\t            const errorToThrow = error.message === utils_1.BROKER_ERRORS.getInfoForIntentsByContext ? 'ResolverUnavailable' : error.message;\n\t            throw new Error(errorToThrow);\n\t        }\n\t    }\n\t    /**\n\t     * Raises a specific intent for resolution against apps registered with the desktop agent.\n\t     * @param intent Name of the Intent\n\t     * @param context Context associated with the Intent\n\t     * @param app\n\t     *\n\t     * @tutorial fdc3v2.raiseIntent\n\t     */\n\t    async raiseIntent(intent, context, app) {\n\t        this.wire.sendAction('fdc3-raise-intent').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        try {\n\t            if (typeof app === 'string') {\n\t                console.warn('Passing a string as the app parameter is deprecated, please use an AppIdentifier ({ appId: string; instanceId?: string }).');\n\t            }\n\t            return (0, utils_2.getIntentResolution)(this.client, context, app, intent);\n\t        }\n\t        catch (error) {\n\t            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fireIntent ? 'ResolverUnavailable' : error.message;\n\t            throw new Error(errorToThrow);\n\t        }\n\t    }\n\t    /**\n\t     * Finds and raises an intent against apps registered with the desktop agent based purely on the type of the context data.\n\t     * @param context Context associated with the Intent\n\t     * @param app\n\t     *\n\t     * @tutorial fdc3v2.raiseIntentForContext\n\t     */\n\t    async raiseIntentForContext(context, app) {\n\t        // TODO: We have to do the same thing we do for raiseIntent here as well.\n\t        this.wire.sendAction('fdc3-raise-intent-for-context').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        try {\n\t            if (typeof app === 'string') {\n\t                console.warn('Passing a string as the app parameter is deprecated, please use an AppIdentifier ({ appId: string; instanceId?: string }).');\n\t            }\n\t            return (0, utils_2.getIntentResolution)(this.client, context, app);\n\t        }\n\t        catch (error) {\n\t            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fireIntent ? 'ResolverUnavailable' : error.message;\n\t            throw new Error(errorToThrow);\n\t        }\n\t    }\n\t    /**\n\t     * Adds a listener for incoming intents.\n\t     * @param intent  Name of the Intent\n\t     * @param handler A callback that handles a context event and may return a promise of a Context or Channel object to be returned to the application that raised the intent.\n\t     *\n\t     * @tutorial fdc3.addIntentListener\n\t     */\n\t    async addIntentListener(intent, handler) {\n\t        this.wire.sendAction('fdc3-add-intent-listener').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        if (typeof intent !== 'string') {\n\t            throw new Error('First argument must be an Intent name');\n\t        }\n\t        // The FDC3 Intenter handler only expects the context and contextMetadata to be passed to the handler,\n\t        // so we wrap it here and only pass those paramaters.\n\t        const contextHandler = async (raisedIntent) => {\n\t            let intentResult;\n\t            let intentResultToSend;\n\t            const { context, metadata: intentMetadata } = raisedIntent;\n\t            const { contextMetadata, metadata, ...rest } = context;\n\t            const intentResolutionResultId = intentMetadata?.intentResolutionResultId || metadata?.intentResolutionResultId;\n\t            try {\n\t                const newContext = metadata ? { metadata, ...rest } : { ...rest };\n\t                intentResult = await handler(newContext, contextMetadata);\n\t                intentResultToSend = intentResult;\n\t            }\n\t            catch (error) {\n\t                intentResult = error;\n\t                intentResultToSend = { error: true };\n\t            }\n\t            if (intentResolutionResultId) {\n\t                this.fin.InterApplicationBus.publish(intentResolutionResultId, intentResultToSend).catch(() => null);\n\t            }\n\t            if (intentResult instanceof Error) {\n\t                throw new Error(intentResult.message);\n\t            }\n\t            return intentResult;\n\t        };\n\t        return this.client.registerIntentHandler(contextHandler, intent, { fdc3Version: '2.0' });\n\t    }\n\t    /**\n\t     * Returns a Channel object for the specified channel, creating it as an App Channel if it does not exist.\n\t     * @param channelId\n\t     *\n\t     * @tutorial fdc3.getOrCreateChannel\n\t     */\n\t    async getOrCreateChannel(channelId) {\n\t        return super.getOrCreateChannel(channelId);\n\t    }\n\t    /**\n\t     * Returns a Channel with an auto-generated identity that is intended for private communication between applications. Primarily used to create channels that will be returned to other applications via an IntentResolution for a raised intent.\n\t     *\n\t     * @tutorial fdc3v2.createPrivateChannel\n\t     */\n\t    async createPrivateChannel() {\n\t        const channelId = (0, utils_1.generateId)();\n\t        await InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'createPrivateChannelProvider', { channelId });\n\t        const channelClient = await this.fin.InterApplicationBus.Channel.connect(channelId);\n\t        const newPrivateChannelClient = new PrivateChannelClient_1.PrivateChannelClient(channelClient, channelId);\n\t        return (0, utils_2.buildPrivateChannelObject)(newPrivateChannelClient);\n\t    }\n\t    /**\n\t     * Retrieves a list of the User Channels available for the app to join.\n\t     *\n\t     * @tutorial fdc3v2.getUserChannels\n\t     */\n\t    async getUserChannels() {\n\t        const channels = await this.client.getContextGroups();\n\t        // fdc3 implementation of getUserChannels returns on array of channels, have to decorate over\n\t        // this so people know that these APIs are not supported\n\t        return channels.map((channel) => {\n\t            // @ts-expect-error TODO [CORE-1524]\n\t            return { ...channel, type: 'user', ...(0, utils_2.getUnsupportedChannelApis)('User') };\n\t        });\n\t    }\n\t    /**\n\t     * Retrieves a list of the User Channels available for the app to join.\n\t     *\n\t     * @deprecated Please use {@link fdc3.getUserChannels fdc3.getUserChannels} instead\n\t     * @tutorial fdc3.getSystemChannels\n\t     */\n\t    async getSystemChannels() {\n\t        console.warn('This API has been deprecated. Please use fdc3.getUserChannels instead.');\n\t        return super.getSystemChannels();\n\t    }\n\t    /**\n\t     * Join an app to a specified User channel.\n\t     * @param channelId Channel name\n\t     *\n\t     * @tutorial fdc3v2.joinUserChannel\n\t     */\n\t    async joinUserChannel(channelId) {\n\t        return super.joinChannel(channelId);\n\t    }\n\t    /**\n\t     * Join an app to a specified User channel.\n\t     * @param channelId Channel name\n\t     * @deprecated Please use {@link fdc3.joinUserChannel fdc3.joinUserChannel} instead\n\t     *\n\t     * @tutorial fdc3.joinChannel\n\t     */\n\t    async joinChannel(channelId) {\n\t        console.warn('This API has been deprecated. Please use fdc3.joinUserChannel instead.');\n\t        return super.joinChannel(channelId);\n\t    }\n\t    /**\n\t     * Returns the Channel object for the current User channel membership\n\t     *\n\t     * @tutorial fdc3.getCurrentChannel\n\t     */\n\t    async getCurrentChannel() {\n\t        const currentChannel = await super.getCurrentChannel();\n\t        if (!currentChannel) {\n\t            return null;\n\t        }\n\t        return {\n\t            ...currentChannel,\n\t            type: 'user',\n\t            broadcast: this.broadcast.bind(this)\n\t        };\n\t    }\n\t    /**\n\t     * Retrieves information about the FDC3 implementation, including the supported version of the FDC3 specification, the name of the provider of the implementation, its own version number, details of whether optional API features are implemented and the metadata of the calling application according to the desktop agent.\n\t     * fdc3HandleGetInfo must be overridden in the InteropBroker so that the ImplementationMetadata will have the appMetadata info.\n\t     *\n\t     * @tutorial fdc3v2.getInfo\n\t     */\n\t    async getInfo() {\n\t        return InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'fdc3v2GetInfo', { fdc3Version: '2.0' });\n\t    }\n\t}\n\tfdc32_0.Fdc3Module2 = Fdc3Module2;\n\treturn fdc32_0;\n}\n\nvar hasRequiredInteropClient;\n\nfunction requireInteropClient () {\n\tif (hasRequiredInteropClient) return InteropClient;\n\thasRequiredInteropClient = 1;\n\tvar __classPrivateFieldSet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n\t    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n\t    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n\t    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n\t    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n\t};\n\tvar __classPrivateFieldGet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n\t    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n\t    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n\t    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n\t};\n\tvar __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {\n\t    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n\t};\n\tvar _InteropClient_clientPromise, _InteropClient_sessionContextGroups;\n\tObject.defineProperty(InteropClient, \"__esModule\", { value: true });\n\tInteropClient.InteropClient = void 0;\n\tconst base_1 = base;\n\tconst SessionContextGroupClient_1 = __importDefault(SessionContextGroupClient$1);\n\tconst fdc3_1_2_1 = requireFdc31_2();\n\tconst fdc3_2_0_1 = requireFdc32_0();\n\tconst utils_1 = utils$3;\n\t/**\n\t * The Interop Client API is broken up into two groups:\n\t *\n\t * **Content Facing APIs** - For Application Developers putting Views into a Platform Window, who care about Context. These are APIs that send out and receive the Context data that flows between applications. Think of this as the Water in the Interop Pipes.\n\t *\n\t * **Context Grouping APIs** - For Platform Developers, to add and remove Views to and from Context Groups. These APIs are utilized under-the-hood in Platforms, so they don't need to be used to participate in Interop. These are the APIs that decide which entities the context data flows between. Think of these as the valves or pipes that control the flow of Context Data for Interop.\n\t *\n\t * ---\n\t *\n\t * All APIs are available at the `fin.me.interop` namespace.\n\t *\n\t * ---\n\t *\n\t * **You only need 2 things to participate in Interop Context Grouping:**\n\t * * A Context Handler for incoming context: {@link InteropClient#addContextHandler addContextHandler(handler, contextType?)}\n\t * * Call setContext on your context group when you want to share context with other group members: {@link InteropClient#setContext setContext(context)}\n\t *\n\t * ---\n\t *\n\t * ##### Constructor\n\t * Returned by {@link Interop.connectSync Interop.connectSync}.\n\t *\n\t * ---\n\t *\n\t * ##### Interop methods intended for Views\n\t *\n\t *\n\t * **Context Groups API**\n\t *  * {@link InteropClient#addContextHandler addContextHandler(handler, contextType?)}\n\t *  * {@link InteropClient#setContext setContext(context)}\n\t *  * {@link InteropClient#getCurrentContext getCurrentContext(contextType?)}\n\t *  * {@link InteropClient#joinSessionContextGroup joinSessionContextGroup(sessionContextGroupId)}\n\t *\n\t *\n\t * **Intents API**\n\t *  * {@link InteropClient#fireIntent fireIntent(intent)}\n\t *  * {@link InteropClient#registerIntentHandler registerIntentHandler(intentHandler, intentName)}\n\t *  * {@link InteropClient#getInfoForIntent getInfoForIntent(infoForIntentOptions)}\n\t *  * {@link InteropClient#getInfoForIntentsByContext getInfoForIntentsByContext(context)}\n\t *  * {@link InteropClient#fireIntentForContext fireIntentForContext(contextForIntent)}\n\t *\n\t * ##### Interop methods intended for Windows\n\t *  * {@link InteropClient#getContextGroups getContextGroups()}\n\t *  * {@link InteropClient#joinContextGroup joinContextGroup(contextGroupId, target?)}\n\t *  * {@link InteropClient#removeFromContextGroup removeFromContextGroup(target?)}\n\t *  * {@link InteropClient#getInfoForContextGroup getInfoForContextGroup(contextGroupId)}\n\t *  * {@link InteropClient#getAllClientsInContextGroup getAllClientsInContextGroup(contextGroupId)}\n\t *\n\t */\n\tlet InteropClient$1 = class InteropClient extends base_1.Base {\n\t    /**\n\t     * @internal\n\t     */\n\t    constructor(wire, clientPromise) {\n\t        super(wire);\n\t        _InteropClient_clientPromise.set(this, void 0);\n\t        _InteropClient_sessionContextGroups.set(this, void 0);\n\t        __classPrivateFieldSet(this, _InteropClient_sessionContextGroups, new Map(), \"f\");\n\t        __classPrivateFieldSet(this, _InteropClient_clientPromise, clientPromise, \"f\");\n\t    }\n\t    /*\n\t    Client APIs\n\t    */\n\t    /**\n\t     * Sets a context for the context group of the current entity.\n\t     *\n\t     * @remarks The entity must be part of a context group in order set a context.\n\t     *\n\t     * @param context - New context to set.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * setInstrumentContext = async (ticker) => {\n\t     *     fin.me.interop.setContext({type: 'instrument', id: {ticker}})\n\t     * }\n\t     *\n\t     * // The user clicks an instrument of interest. We want to set that Instrument context so that the rest of our workflow updates with information for that instrument\n\t     * instrumentElement.on('click', (evt) => {\n\t     *     setInstrumentContext(evt.ticker)\n\t     * })\n\t     * ```\n\t     */\n\t    async setContext(context) {\n\t        this.wire.sendAction('interop-client-set-context').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        return client.dispatch('setContext', { context });\n\t    }\n\t    /**\n\t     * Add a context handler for incoming context. If an entity is part of a context group, and then sets its context handler,\n\t     * it will receive all of its declared contexts.\n\t     *\n\t     * @param handler - Handler for incoming context.\n\t     * @param contextType - The type of context you wish to handle.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * function handleIncomingContext(contextInfo) {\n\t     *     const { type, id } = contextInfo;\n\t     *     switch (type) {\n\t     *         case 'instrument':\n\t     *             handleInstrumentContext(contextInfo);\n\t     *             break;\n\t     *         case 'country':\n\t     *             handleCountryContext(contextInfo);\n\t     *             break;\n\t     *\n\t     *         default:\n\t     *             break;\n\t     *     }\n\t     * }\n\t     *\n\t     *\n\t     * function handleInstrumentContext(contextInfo) {\n\t     *     const { type, id } = contextInfo;\n\t     *     console.log('contextInfo for instrument', contextInfo)\n\t     * }\n\t     *\n\t     * function handleCountryContext(contextInfo) {\n\t     *     const { type, id } = contextInfo;\n\t     *     console.log('contextInfo for country', contextInfo)\n\t     * }\n\t     *\n\t     * fin.me.interop.addContextHandler(handleIncomingContext);\n\t     * ```\n\t     *\n\t     *\n\t     * Passing in a context type as the second parameter will cause the handler to only be invoked with that context type.\n\t     *\n\t     * ```js\n\t     * function handleInstrumentContext(contextInfo) {\n\t     *     const { type, id } = contextInfo;\n\t     *     console.log('contextInfo for instrument', contextInfo)\n\t     * }\n\t     *\n\t     * function handleCountryContext(contextInfo) {\n\t     *     const { type, id } = contextInfo;\n\t     *     console.log('contextInfo for country', contextInfo)\n\t     * }\n\t     *\n\t     *\n\t     * fin.me.interop.addContextHandler(handleInstrumentContext, 'instrument')\n\t     * fin.me.interop.addContextHandler(handleCountryContext, 'country')\n\t     * ```\n\t     */\n\t    async addContextHandler(handler, contextType) {\n\t        this.wire.sendAction('interop-client-add-context-handler').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        if (typeof handler !== 'function') {\n\t            throw new Error(\"Non-function argument passed to the first parameter 'handler'. Be aware that the argument order does not match the FDC3 standard.\");\n\t        }\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        let handlerId;\n\t        if (contextType) {\n\t            handlerId = `invokeContextHandler-${contextType}-${(0, utils_1.generateId)()}`;\n\t        }\n\t        else {\n\t            handlerId = 'invokeContextHandler';\n\t        }\n\t        const wrappedHandler = (0, utils_1.wrapContextHandler)(handler, handlerId);\n\t        client.register(handlerId, wrappedHandler);\n\t        await client.dispatch('contextHandlerRegistered', { handlerId, contextType });\n\t        return {\n\t            unsubscribe: async () => {\n\t                client.remove(handlerId);\n\t                await client.dispatch('removeContextHandler', { handlerId });\n\t            }\n\t        };\n\t    }\n\t    /*\n\t    Platform Window APIs\n\t    */\n\t    /**\n\t     * Returns the Interop-Broker-defined context groups available for an entity to join.\n\t     * Used by Platform Windows.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.me.interop.getContextGroups()\n\t     *         .then(contextGroups => {\n\t     *             contextGroups.forEach(contextGroup => {\n\t     *                 console.log(contextGroup.displayMetadata.name)\n\t     *                 console.log(contextGroup.displayMetadata.color)\n\t     *             })\n\t     *         })\n\t     * ```\n\t     */\n\t    async getContextGroups() {\n\t        this.wire.sendAction('interop-client-get-context-groups').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        return client.dispatch('getContextGroups');\n\t    }\n\t    /**\n\t     * Join all Interop Clients at the given identity to context group `contextGroupId`.\n\t     * If no target is specified, it adds the sender to the context group.\n\t     *\n\t     * @remarks Because multiple Channel connections/Interop Clients can potentially exist at a `uuid`/`name` combo, we currently join all Channel connections/Interop Clients at the given identity to the context group.\n\t     * If an `endpointId` is provided (which is unlikely, unless the call is coming from an external adapter), then we only join that single connection to the context group.\n\t     * For all intents and purposes, there will only be 1 connection present in Platform and Browser implmentations, so this point is more-or-less moot.\n\t     * Used by Platform Windows.\n\t     *\n\t     * @param contextGroupId - Id of the context group.\n\t     * @param target - Identity of the entity you wish to join to a context group.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * joinViewToContextGroup = async (contextGroupId, view) => {\n\t     *     await fin.me.interop.joinContextGroup(contextGroupId, view);\n\t     * }\n\t     *\n\t     * getLastFocusedView()\n\t     *     .then(lastFocusedViewIdentity => {\n\t     *         joinViewToContextGroup('red', lastFocusedViewIdentity)\n\t     *     })\n\t     * ```\n\t     */\n\t    async joinContextGroup(contextGroupId, target) {\n\t        this.wire.sendAction('interop-client-join-context-group').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        if (!contextGroupId) {\n\t            throw new Error('No contextGroupId specified for joinContextGroup.');\n\t        }\n\t        return client.dispatch('joinContextGroup', { contextGroupId, target });\n\t    }\n\t    /**\n\t     * Removes the specified target from a context group.\n\t     * If no target is specified, it removes the sender from their context group.\n\t     * Used by Platform Windows.\n\t     *\n\t     * @param target - Identity of the entity you wish to join to a context group.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * removeViewFromContextGroup = async (view) => {\n\t     *     await fin.me.interop.removeFromContextGroup(view);\n\t     * }\n\t     *\n\t     * getLastFocusedView()\n\t     *     .then(lastFocusedViewIdentity => {\n\t     *         removeViewFromContextGroup(lastFocusedViewIdentity)\n\t     *     })\n\t     * ```\n\t     */\n\t    async removeFromContextGroup(target) {\n\t        this.wire.sendAction('interop-client-remove-from-context-group').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        return client.dispatch('removeFromContextGroup', { target });\n\t    }\n\t    /**\n\t     * Gets all clients for a context group.\n\t     *\n\t     * @remarks **This is primarily used for platform windows. Views within a platform should not have to use this API.**\n\t     *\n\t     * Returns the Interop-Broker-defined context groups available for an entity to join.\n\t     * @param contextGroupId - The id of context group you wish to get clients for.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.me.interop.getAllClientsInContextGroup('red')\n\t     *     .then(clientsInContextGroup => {\n\t     *         console.log(clientsInContextGroup)\n\t     *     })\n\t     * ```\n\t     */\n\t    async getAllClientsInContextGroup(contextGroupId) {\n\t        this.wire.sendAction('interop-client-get-all-clients-in-context-group').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        if (!contextGroupId) {\n\t            throw new Error('No contextGroupId specified for getAllClientsInContextGroup.');\n\t        }\n\t        return client.dispatch('getAllClientsInContextGroup', { contextGroupId });\n\t    }\n\t    /**\n\t     * Gets display info for a context group\n\t     *\n\t     * @remarks Used by Platform Windows.\n\t     * @param contextGroupId - The id of context group you wish to get display info for.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.me.interop.getInfoForContextGroup('red')\n\t     *     .then(contextGroupInfo => {\n\t     *         console.log(contextGroupInfo.displayMetadata.name)\n\t     *         console.log(contextGroupInfo.displayMetadata.color)\n\t     *     })\n\t     * ```\n\t     */\n\t    async getInfoForContextGroup(contextGroupId) {\n\t        this.wire.sendAction('interop-client-get-info-for-context-group').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        if (!contextGroupId) {\n\t            throw new Error('No contextGroupId specified for getInfoForContextGroup.');\n\t        }\n\t        return client.dispatch('getInfoForContextGroup', { contextGroupId });\n\t    }\n\t    /**\n\t     * Sends an intent to the Interop Broker to resolve.\n\t     * @param intent - The combination of an action and a context that is passed to an application for resolution.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * // View wants to fire an Intent after a user clicks on a ticker\n\t     * tickerElement.on('click', (element) => {\n\t     *     const ticker = element.innerText;\n\t     *     const intent = {\n\t     *         name: 'ViewChart',\n\t     *         context: {type: 'fdc3.instrument', id: { ticker }}\n\t     *     }\n\t     *\n\t     *     fin.me.interop.fireIntent(intent);\n\t     * })\n\t     * ```\n\t     */\n\t    async fireIntent(intent) {\n\t        this.wire.sendAction('interop-client-fire-intent').catch((e) => {\n\t            // don't expose, this is only for api analytics purposes\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        return client.dispatch('fireIntent', intent);\n\t    }\n\t    /**\n\t     * Adds an intent handler for incoming intents. The last intent sent of the name subscribed to will be received.\n\t     * @param handler - Registered function meant to handle a specific intent type.\n\t     * @param intentName - The name of an intent.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * const intentHandler = (intent) => {\n\t     *     const { context } = intent;\n\t     *     myViewChartHandler(context);\n\t     * };\n\t     *\n\t     * const subscription = await fin.me.interop.registerIntentHandler(intentHandler, 'ViewChart');\n\t     *\n\t     * function myAppCloseSequence() {\n\t     *     // to unsubscribe the handler, simply call:\n\t     *     subscription.unsubscribe();\n\t     * }\n\t     * ```\n\t     */\n\t    async registerIntentHandler(handler, intentName, options) {\n\t        this.wire.sendAction('interop-client-register-intent-handler').catch((e) => {\n\t            // don't expose, this is only for api analytics purposes\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        const handlerId = `intent-handler-${intentName}`;\n\t        const wrappedHandler = (0, utils_1.wrapIntentHandler)(handler, handlerId);\n\t        try {\n\t            await client.register(handlerId, wrappedHandler);\n\t            await client.dispatch('intentHandlerRegistered', { handlerId, ...options });\n\t        }\n\t        catch (error) {\n\t            throw new Error('Unable to register intent handler');\n\t        }\n\t        return {\n\t            unsubscribe: async () => {\n\t                client.remove(handlerId);\n\t            }\n\t        };\n\t    }\n\t    /**\n\t     * Gets the last context of the Context Group currently subscribed to. It takes an optional Context Type and returns the\n\t     * last context of that type.\n\t     * @param contextType\n\t     *\n\t     * @example\n\t     * ```js\n\t     * await fin.me.interop.joinContextGroup('yellow');\n\t     * await fin.me.interop.setContext({ type: 'instrument', id: { ticker: 'FOO' }});\n\t     * const currentContext = await fin.me.interop.getCurrentContext();\n\t     *\n\t     * // with a specific context\n\t     * await fin.me.interop.joinContextGroup('yellow');\n\t     * await fin.me.interop.setContext({ type: 'country', id: { ISOALPHA3: 'US' }});\n\t     * await fin.me.interop.setContext({ type: 'instrument', id: { ticker: 'FOO' }});\n\t     * const currentContext = await fin.me.interop.getCurrentContext('country');\n\t     * ```\n\t     */\n\t    async getCurrentContext(contextType) {\n\t        this.wire.sendAction('interop-client-get-current-context').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        return client.dispatch('getCurrentContext', { contextType });\n\t    }\n\t    /**\n\t     * Get information for a particular Intent from the Interop Broker.\n\t     *\n\t     * @remarks To resolve this info, the function handleInfoForIntent is meant to be overridden in the Interop Broker.\n\t     * The format for the response will be determined by the App Provider overriding the function.\n\t     *\n\t     * @param options\n\t     *\n\t     * @example\n\t     * ```js\n\t     * const intentInfo = await fin.me.interop.getInfoForIntent('ViewChart');\n\t     * ```\n\t     */\n\t    async getInfoForIntent(options) {\n\t        this.wire.sendAction('interop-client-get-info-for-intent').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        return client.dispatch('getInfoForIntent', options);\n\t    }\n\t    /**\n\t     * Get information from the Interop Broker on all Intents that are meant to handle a particular context.\n\t     *\n\t     * @remarks To resolve this info, the function handleInfoForIntentsByContext is meant to be overridden in the Interop Broker.\n\t     * The format for the response will be determined by the App Provider overriding the function.\n\t     *\n\t     * @param context\n\t     *\n\t     * @example\n\t     * ```js\n\t     * tickerElement.on('click', (element) => {\n\t     *     const ticker = element.innerText;\n\t     *\n\t     *     const context = {\n\t     *         type: 'fdc3.instrument',\n\t     *         id: {\n\t     *             ticker\n\t     *         }\n\t     *     }\n\t     *\n\t     *     const intentsInfo = await fin.me.interop.getInfoForIntentByContext(context);\n\t     * })\n\t     * ```\n\t     */\n\t    async getInfoForIntentsByContext(context) {\n\t        this.wire.sendAction('interop-client-get-info-for-intents-by-context').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        return client.dispatch('getInfoForIntentsByContext', context);\n\t    }\n\t    /**\n\t     * Sends a Context that will be resolved to an Intent by the Interop Broker.\n\t     * This context accepts a metadata property.\n\t     *\n\t     * @remarks To resolve this info, the function handleFiredIntentByContext is meant to be overridden in the Interop Broker.\n\t     * The format for the response will be determined by the App Provider overriding the function.\n\t     *\n\t     * @param context\n\t     *\n\t     * @example\n\t     * ```js\n\t     * tickerElement.on('click', (element) => {\n\t     *     const ticker = element.innerText;\n\t     *\n\t     *     const context = {\n\t     *         type: 'fdc3.instrument',\n\t     *         id: {\n\t     *             ticker\n\t     *         }\n\t     *     }\n\t     *\n\t     *     const intentResolution = await fin.me.interop.fireIntentForContext(context);\n\t     * })\n\t     * ```\n\t     */\n\t    async fireIntentForContext(context) {\n\t        this.wire.sendAction('interop-client-fire-intent-for-context').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        return client.dispatch('fireIntentForContext', context);\n\t    }\n\t    /**\n\t     * Join the current entity to session context group `sessionContextGroupId` and return a sessionContextGroup instance.\n\t     * If the sessionContextGroup doesn't exist, one will get created.\n\t     *\n\t     * @remarks Session Context Groups do not persist between runs and aren't present on snapshots.\n\t     * @param sessionContextGroupId - Id of the context group.\n\t     *\n\t     * @example\n\t     * Say we want to have a Session Context Group that holds UI theme information for all apps to consume:\n\t     *\n\t     * My color-picker View:\n\t     * ```js\n\t     *     const themeSessionContextGroup = await fin.me.interop.joinSessionContextGroup('theme');\n\t     *\n\t     *     const myColorPickerElement = document.getElementById('color-palette-picker');\n\t     *     myColorPickerElement.addEventListener('change', event => {\n\t     *         themeSessionContextGroup.setContext({ type: 'color-palette', selection: event.value });\n\t     *     });\n\t     * ```\n\t     *\n\t     * In other views:\n\t     * ```js\n\t     *     const themeSessionContextGroup = await fin.me.interop.joinSessionContextGroup('theme');\n\t     *\n\t     *     const changeColorPalette = ({ selection }) => {\n\t     *         // change the color palette to the selection\n\t     *     };\n\t     *\n\t     *     // If the context is already set by the time the handler was set, the handler will get invoked immediately with the current context.\n\t     *     themeSessionContextGroup.addContextHandler(changeColorPalette, 'color-palette');\n\t     * ```\n\t     */\n\t    async joinSessionContextGroup(sessionContextGroupId) {\n\t        try {\n\t            const currentSessionContextGroup = __classPrivateFieldGet(this, _InteropClient_sessionContextGroups, \"f\").get(sessionContextGroupId);\n\t            if (currentSessionContextGroup) {\n\t                return currentSessionContextGroup.getUserInstance();\n\t            }\n\t            const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t            const { hasConflict } = await client.dispatch('sessionContextGroup:createIfNeeded', {\n\t                sessionContextGroupId\n\t            });\n\t            if (hasConflict) {\n\t                console.warn(`A (non-session) context group with the name \"${sessionContextGroupId}\" already exists. If you are trying to join a Context Group, call joinContextGroup instead.`);\n\t            }\n\t            const newSessionContextGroup = new SessionContextGroupClient_1.default(this.wire, __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\"), sessionContextGroupId);\n\t            __classPrivateFieldGet(this, _InteropClient_sessionContextGroups, \"f\").set(sessionContextGroupId, newSessionContextGroup);\n\t            return newSessionContextGroup.getUserInstance();\n\t        }\n\t        catch (error) {\n\t            console.error(`Error thrown trying to create Session Context Group with id \"${sessionContextGroupId}\": ${error}`);\n\t            throw error;\n\t        }\n\t    }\n\t    /**\n\t     * Register a listener that is called when the Interop Client has been disconnected from the Interop Broker.\n\t     * Only one listener per Interop Client can be set.\n\t     * @param listener\n\t     *\n\t     * @example\n\t     * ```js\n\t     * const listener = (event) => {\n\t     *     const { type, topic, brokerName} = event;\n\t     *     console.log(`Disconnected from Interop Broker ${brokerName} `);\n\t     * }\n\t     *\n\t     * await fin.me.interop.onDisconnection(listener);\n\t     * ```\n\t     */\n\t    async onDisconnection(listener) {\n\t        this.wire.sendAction('interop-client-add-ondisconnection-listener').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        return client.onDisconnection((event) => {\n\t            const { uuid } = event;\n\t            listener({ type: 'interop-broker', topic: 'disconnected', brokerName: uuid });\n\t        });\n\t    }\n\t    getFDC3Sync(version) {\n\t        switch (version) {\n\t            case '1.2':\n\t                return new fdc3_1_2_1.Fdc3Module(() => this, this.wire);\n\t            case '2.0':\n\t                return new fdc3_2_0_1.Fdc3Module2(() => this, this.wire);\n\t            default:\n\t                throw new Error(`Invalid FDC3 version provided: ${version}. Must be '1.2' or '2.0'`);\n\t        }\n\t    }\n\t    async getFDC3(version) {\n\t        return this.getFDC3Sync(version);\n\t    }\n\t    /**\n\t     * @internal\n\t     *\n\t     * Used to ferry fdc3-only calls from the fdc3 shim to the Interop Broker\n\t     */\n\t    static async ferryFdc3Call(interopClient, action, payload) {\n\t        const client = await __classPrivateFieldGet(interopClient, _InteropClient_clientPromise, \"f\");\n\t        return client.dispatch(action, payload || null);\n\t    }\n\t};\n\tInteropClient.InteropClient = InteropClient$1;\n\t_InteropClient_clientPromise = new WeakMap(), _InteropClient_sessionContextGroups = new WeakMap();\n\treturn InteropClient;\n}\n\nvar overrideCheck = {};\n\nvar hasRequiredOverrideCheck;\n\nfunction requireOverrideCheck () {\n\tif (hasRequiredOverrideCheck) return overrideCheck;\n\thasRequiredOverrideCheck = 1;\n\tObject.defineProperty(overrideCheck, \"__esModule\", { value: true });\n\toverrideCheck.overrideCheck = overrideCheck.checkFDC32Overrides = overrideCheck.getDefaultViewFdc3VersionFromAppInfo = void 0;\n\tconst InteropBroker_1 = requireInteropBroker();\n\tfunction getDefaultViewFdc3VersionFromAppInfo({ manifest, initialOptions }) {\n\t    const setVersion = manifest?.platform?.defaultViewOptions?.fdc3InteropApi ?? initialOptions.defaultViewOptions?.fdc3InteropApi;\n\t    return ['1.2', '2.0'].includes(setVersion ?? '') ? setVersion : undefined;\n\t}\n\toverrideCheck.getDefaultViewFdc3VersionFromAppInfo = getDefaultViewFdc3VersionFromAppInfo;\n\tfunction checkFDC32Overrides(overriddenBroker) {\n\t    // These are the APIs that must be overridden for FDC3 2.0 compliance\n\t    const mustOverrideAPIs = [\n\t        'fdc3HandleFindInstances',\n\t        'handleInfoForIntent',\n\t        'handleInfoForIntentsByContext',\n\t        'fdc3HandleGetAppMetadata',\n\t        'fdc3HandleGetInfo',\n\t        'fdc3HandleOpen',\n\t        'handleFiredIntent',\n\t        'handleFiredIntentForContext'\n\t    ];\n\t    return mustOverrideAPIs.filter((api) => {\n\t        return overriddenBroker[api] === InteropBroker_1.InteropBroker.prototype[api];\n\t    });\n\t}\n\toverrideCheck.checkFDC32Overrides = checkFDC32Overrides;\n\tfunction overrideCheck$1(overriddenBroker, fdc3InteropApi) {\n\t    if (fdc3InteropApi && fdc3InteropApi === '2.0') {\n\t        const notOverridden = checkFDC32Overrides(overriddenBroker);\n\t        if (notOverridden.length > 0) {\n\t            console.warn(`WARNING: FDC3 2.0 has been set as a default option for Views in this Platform, but the required InteropBroker APIs for FDC3 2.0 compliance have not all been overridden.\\nThe following APIs need to be overridden:\\n${notOverridden.join('\\n')}`);\n\t        }\n\t    }\n\t}\n\toverrideCheck.overrideCheck = overrideCheck$1;\n\treturn overrideCheck;\n}\n\nvar hasRequiredFactory;\n\nfunction requireFactory () {\n\tif (hasRequiredFactory) return Factory$1;\n\thasRequiredFactory = 1;\n\tvar __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {\n\t    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n\t};\n\tObject.defineProperty(Factory$1, \"__esModule\", { value: true });\n\tFactory$1.InteropModule = void 0;\n\tconst cloneDeep_1 = __importDefault(require$$0$1);\n\tconst inaccessibleObject_1 = inaccessibleObject;\n\tconst base_1 = base;\n\tconst InteropBroker_1 = requireInteropBroker();\n\tconst InteropClient_1 = requireInteropClient();\n\tconst overrideCheck_1 = requireOverrideCheck();\n\tconst common_utils_1 = commonUtils;\n\tconst defaultOverride = (Class) => new Class();\n\tconst BrokerParamAccessError = 'You have attempted to use or modify InteropBroker parameters, which is not allowed. You are likely using an older InteropBroker override scheme. Please consult our Interop docs for guidance on migrating to the new override scheme.';\n\t/**\n\t * Manages creation of Interop Brokers and Interop Clients. These APIs are called under-the-hood in Platforms.\n\t *\n\t */\n\tclass InteropModule extends base_1.Base {\n\t    /**\n\t     * Initializes an Interop Broker. This is called under-the-hood for Platforms.\n\t     *\n\t     * @remarks For Platforms, this is set up automatically. We advise to only create your own Interop Broker\n\t     * when not using a Platform app. You can override functions in the Interop Broker. More info {@link InteropBroker here}.\n\t     *\n\t     * @param name - Name of the Interop Broker.\n\t     * @param override - A callback function or array of callback functions that can be used to extend or replace default Interop Broker behavior.\n\t     *\n\t     * @example\n\t     * ``` js\n\t     * const interopBroker = await fin.Interop.init('openfin');\n\t     * const contextGroups = await interopBroker.getContextGroups();\n\t     * console.log(contextGroups);\n\t     * ```\n\t     */\n\t    async init(name, override = defaultOverride) {\n\t        this.wire.sendAction('interop-init').catch(() => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        // Allows for manifest-level configuration, without having to override. (e.g. specifying custom context groups)\n\t        const options = await this.wire.environment.getInteropInfo(this.wire.getFin());\n\t        const objectThatThrows = (0, inaccessibleObject_1.createUnusableObject)(BrokerParamAccessError);\n\t        const warningOptsClone = (0, inaccessibleObject_1.createWarningObject)(BrokerParamAccessError, (0, cloneDeep_1.default)(options));\n\t        const getProvider = () => {\n\t            return this.fin.InterApplicationBus.Channel.create(`interop-broker-${name}`);\n\t        };\n\t        const throwingGetProvider = async () => {\n\t            // eslint-disable-next-line no-console\n\t            throw new Error(BrokerParamAccessError);\n\t        };\n\t        const OverrideableBroker = InteropBroker_1.InteropBroker.createClosedConstructor(this.wire, getProvider, options);\n\t        let broker;\n\t        if (Array.isArray(override)) {\n\t            const BrokerConstructor = (0, common_utils_1.overrideFromComposables)(...override)(OverrideableBroker);\n\t            // We need to use these objects because removing them entirely would be a breaking change and we want an informative error\n\t            // @ts-expect-error\n\t            broker = new BrokerConstructor(objectThatThrows, throwingGetProvider, warningOptsClone);\n\t        }\n\t        else {\n\t            // We need to use these objects because removing them entirely would be a breaking change and we want an informative error\n\t            // @ts-expect-error\n\t            broker = await override(OverrideableBroker, objectThatThrows, throwingGetProvider, warningOptsClone);\n\t        }\n\t        (0, overrideCheck_1.overrideCheck)(broker, options.fdc3Version);\n\t        return broker;\n\t    }\n\t    /**\n\t     * Connects a client to an Interop broker. This is called under-the-hood for Views in a Platform.\n\t     *\n\t     * @remarks\n\t     * @param name - The name of the Interop Broker to connect to. For Platforms, this will default to the uuid of the Platform.\n\t     * @param interopConfig - Information relevant to the Interop Broker. Typically a declaration of\n\t     * what context(s) the entity wants to subscribe to, and the current Context Group of the entity.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * const interopConfig = {\n\t     *     currentContextGroup: 'green'\n\t     * }\n\t     *\n\t     * const interopBroker = await fin.Interop.init('openfin');\n\t     * const client = await fin.Interop.connectSync('openfin', interopConfig);\n\t     * const contextGroupInfo = await client.getInfoForContextGroup();\n\t     * console.log(contextGroupInfo);\n\t     * ```\n\t     */\n\t    connectSync(name, interopConfig) {\n\t        this.wire.sendAction('interop-connect-sync').catch(() => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        return new InteropClient_1.InteropClient(this.wire, this.wire.environment.whenReady().then(() => {\n\t            return this.fin.InterApplicationBus.Channel.connect(`interop-broker-${name}`, {\n\t                payload: interopConfig\n\t            });\n\t        }));\n\t    }\n\t}\n\tFactory$1.InteropModule = InteropModule;\n\treturn Factory$1;\n}\n\nvar hasRequiredInterop;\n\nfunction requireInterop () {\n\tif (hasRequiredInterop) return interop;\n\thasRequiredInterop = 1;\n\t(function (exports) {\n\t\t/**\n\t\t * Entry point for the OpenFin `Interop` API (`fin.Interop`).\n\t\t *\n\t\t * * {@link InteropModule} contains static members of the `Interop` API (available under `fin.Interop`)\n\t\t * * {@link InteropClient} and {@link InteropBroker} document instances of their respective classes.\n\t\t *\n\t\t * @packageDocumentation\n\t\t */\n\t\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t\t    if (k2 === undefined) k2 = k;\n\t\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t\t    }\n\t\t    Object.defineProperty(o, k2, desc);\n\t\t}) : (function(o, m, k, k2) {\n\t\t    if (k2 === undefined) k2 = k;\n\t\t    o[k2] = m[k];\n\t\t}));\n\t\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t\t};\n\t\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t\t__exportStar(requireFactory(), exports);\n\t\t__exportStar(requireInteropClient(), exports);\n\t\t__exportStar(requireInteropBroker(), exports); \n\t} (interop));\n\treturn interop;\n}\n\nvar snapshotSource = {};\n\nvar Factory = {};\n\nvar Instance = {};\n\nvar utils = {};\n\nObject.defineProperty(utils, \"__esModule\", { value: true });\nutils.getSnapshotSourceChannelName = void 0;\nconst channelPrefix = 'snapshot-source-provider-';\nconst getSnapshotSourceChannelName = (id) => `${channelPrefix}${id.uuid}`;\nutils.getSnapshotSourceChannelName = getSnapshotSourceChannelName;\n\nvar __classPrivateFieldSet$1 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar __classPrivateFieldGet$1 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar _SnapshotSource_identity, _SnapshotSource_getConnection, _SnapshotSource_getClient, _SnapshotSource_startConnection, _SnapshotSource_setUpConnectionListener;\nObject.defineProperty(Instance, \"__esModule\", { value: true });\nInstance.SnapshotSource = void 0;\n/* eslint-disable @typescript-eslint/no-non-null-assertion */\nconst base_1$1 = base;\nconst utils_1$1 = utils;\nconst connectionMap = new Map();\n/**\n * Enables configuring a SnapshotSource with custom getSnapshot and applySnapshot methods.\n *\n * @typeParam Snapshot Implementation-defined shape of an application snapshot.  Allows\n * custom snapshot implementations for legacy applications to define their own snapshot format.\n */\nclass SnapshotSource extends base_1$1.Base {\n    /**\n     * @internal\n     */\n    constructor(wire, id) {\n        super(wire);\n        _SnapshotSource_identity.set(this, void 0);\n        _SnapshotSource_getConnection.set(this, () => {\n            if (!connectionMap.has(this.identity.uuid)) {\n                connectionMap.set(this.identity.uuid, { eventFired: null, clientPromise: null });\n            }\n            return connectionMap.get(this.identity.uuid);\n        });\n        _SnapshotSource_getClient.set(this, () => {\n            if (!__classPrivateFieldGet$1(this, _SnapshotSource_getConnection, \"f\").call(this).clientPromise) {\n                __classPrivateFieldGet$1(this, _SnapshotSource_getConnection, \"f\").call(this).clientPromise = __classPrivateFieldGet$1(this, _SnapshotSource_startConnection, \"f\").call(this);\n            }\n            return __classPrivateFieldGet$1(this, _SnapshotSource_getConnection, \"f\").call(this).clientPromise;\n        });\n        _SnapshotSource_startConnection.set(this, async () => {\n            const channelName = (0, utils_1$1.getSnapshotSourceChannelName)(this.identity);\n            try {\n                if (!__classPrivateFieldGet$1(this, _SnapshotSource_getConnection, \"f\").call(this).eventFired) {\n                    await __classPrivateFieldGet$1(this, _SnapshotSource_setUpConnectionListener, \"f\").call(this);\n                }\n                const client = await this.fin.InterApplicationBus.Channel.connect(channelName, { wait: false });\n                client.onDisconnection(() => {\n                    __classPrivateFieldGet$1(this, _SnapshotSource_getConnection, \"f\").call(this).clientPromise = null;\n                    __classPrivateFieldGet$1(this, _SnapshotSource_getConnection, \"f\").call(this).eventFired = null;\n                });\n                return client;\n            }\n            catch (e) {\n                __classPrivateFieldGet$1(this, _SnapshotSource_getConnection, \"f\").call(this).clientPromise = null;\n                throw new Error(\"The targeted SnapshotSource is not currently initialized. Await this object's ready() method.\");\n            }\n        });\n        _SnapshotSource_setUpConnectionListener.set(this, async () => {\n            const channelName = (0, utils_1$1.getSnapshotSourceChannelName)(this.identity);\n            let resolve;\n            let reject;\n            const eventFired = new Promise((y, n) => {\n                resolve = y;\n                reject = n;\n            });\n            __classPrivateFieldGet$1(this, _SnapshotSource_getConnection, \"f\").call(this).eventFired = eventFired;\n            const listener = async (e) => {\n                try {\n                    if (e.channelName === channelName) {\n                        resolve();\n                        await this.fin.InterApplicationBus.Channel.removeListener('connected', listener);\n                    }\n                }\n                catch (err) {\n                    reject(err);\n                }\n            };\n            await this.fin.InterApplicationBus.Channel.on('connected', listener);\n        });\n        __classPrivateFieldSet$1(this, _SnapshotSource_identity, id, \"f\");\n    }\n    get identity() {\n        return __classPrivateFieldGet$1(this, _SnapshotSource_identity, \"f\");\n    }\n    /**\n     * Method to determine if the SnapshotSource has been initialized.\n     *\n     * @remarks Use when the parent application is starting up to ensure the SnapshotSource is able to accept and\n     * apply a snapshot using the {@link SnapshotSource#applySnapshot applySnapshot} method.\n     *\n     * @example\n     * ```js\n     * let snapshotSource = fin.SnapshotSource.wrapSync(fin.me);\n     *\n     * const snapshotProvider = {\n     *     async getSnapshot() { return 'foo' },\n     *     async applySnapshot(snapshot) {\n     *       console.log(snapshot);\n     *       return undefined;\n     *     }\n     * }\n     * await fin.SnapshotSource.init(snapshotProvider);\n     *\n     * try {\n     *   await snapshotSource.ready();\n     *   await snapshotSource.applySnapshot('foo');\n     * } catch (err) {\n     *   console.log(err)\n     * }\n     * ```\n     */\n    async ready() {\n        this.wire.sendAction('snapshot-source-ready').catch((e) => {\n            // don't expose, analytics-only call\n        });\n        // eslint-disable-next-line no-async-promise-executor\n        try {\n            // If getClient was already called before this, do we have a timing issue where the channel might have been created but we missed the event but this still fails?\n            await __classPrivateFieldGet$1(this, _SnapshotSource_getClient, \"f\").call(this);\n        }\n        catch (e) {\n            // it was not running.\n            await __classPrivateFieldGet$1(this, _SnapshotSource_getConnection, \"f\").call(this).eventFired;\n        }\n    }\n    /**\n     * Call the SnapshotSource's getSnapshot method defined by {@link SnapshotSource.SnapshotSourceModule#init init}.\n     *\n     */\n    async getSnapshot() {\n        this.wire.sendAction('snapshot-source-get-snapshot').catch((e) => {\n            // don't expose, analytics-only call\n        });\n        const client = await __classPrivateFieldGet$1(this, _SnapshotSource_getClient, \"f\").call(this);\n        const response = (await client.dispatch('get-snapshot'));\n        return (await response).snapshot;\n    }\n    /**\n     * Call the SnapshotSource's applySnapshot method defined by {@link SnapshotSource.SnapshotSourceModule#init init}.\n     *\n     */\n    async applySnapshot(snapshot) {\n        this.wire.sendAction('snapshot-source-apply-snapshot').catch((e) => {\n            // don't expose, analytics-only call\n        });\n        const client = await __classPrivateFieldGet$1(this, _SnapshotSource_getClient, \"f\").call(this);\n        return client.dispatch('apply-snapshot', { snapshot });\n    }\n}\nInstance.SnapshotSource = SnapshotSource;\n_SnapshotSource_identity = new WeakMap(), _SnapshotSource_getConnection = new WeakMap(), _SnapshotSource_getClient = new WeakMap(), _SnapshotSource_startConnection = new WeakMap(), _SnapshotSource_setUpConnectionListener = new WeakMap();\n\nObject.defineProperty(Factory, \"__esModule\", { value: true });\nFactory.SnapshotSourceModule = void 0;\nconst base_1 = base;\nconst Instance_1 = Instance;\nconst utils_1 = utils;\n/**\n * Static namespace for OpenFin API methods that interact with the {@link SnapshotSource} class, available under `fin.SnapshotSource`.\n */\nclass SnapshotSourceModule extends base_1.Base {\n    /**\n     * Initializes a SnapshotSource with the getSnapshot and applySnapshot methods defined.\n     *\n     * @typeParam Snapshot Implementation-defined shape of an application snapshot.  Allows\n     * custom snapshot implementations for legacy applications to define their own snapshot format.\n     *\n     * @example\n     * ```js\n     * const snapshotProvider = {\n     *     async getSnapshot() {\n     *       const bounds = await fin.me.getBounds();\n     *       return bounds;\n     *      },\n     *     async applySnapshot(snapshot) {\n     *       await fin.me.setBounds(snapshot);\n     *       return undefined;\n     *     }\n     * }\n     *\n     * await fin.SnapshotSource.init(snapshotProvider);\n     * ```\n     *\n     */\n    async init(provider) {\n        this.wire.sendAction('snapshot-source-init').catch((e) => {\n            // don't expose, analytics-only call\n        });\n        if (typeof provider !== 'object' ||\n            typeof provider.getSnapshot !== 'function' ||\n            typeof provider.applySnapshot !== 'function') {\n            throw new Error('you must pass in a valid SnapshotProvider');\n        }\n        const channel = await this.fin.InterApplicationBus.Channel.create((0, utils_1.getSnapshotSourceChannelName)(this.fin.me));\n        channel.register('get-snapshot', async () => {\n            const snapshot = await provider.getSnapshot();\n            return { snapshot };\n        });\n        channel.register('apply-snapshot', ({ snapshot }) => provider.applySnapshot(snapshot));\n    }\n    /**\n     * Synchronously returns a SnapshotSource object that represents the current SnapshotSource.\n     *\n     * @example\n     * ```js\n     * const snapshotSource = fin.SnapshotSource.wrapSync(fin.me);\n     * // Use wrapped instance's getSnapshot method, e.g.:\n     * const snapshot = await snapshotSource.getSnapshot();\n     * ```\n     */\n    wrapSync(identity) {\n        this.wire.sendAction('snapshot-source-wrap-sync').catch((e) => {\n            // don't expose, analytics-only call\n        });\n        return new Instance_1.SnapshotSource(this.wire, identity);\n    }\n    /**\n     * Asynchronously returns a SnapshotSource object that represents the current SnapshotSource.\n     *\n     * @example\n     * ```js\n     * const snapshotSource = await fin.SnapshotSource.wrap(fin.me);\n     * // Use wrapped instance's getSnapshot method, e.g.:\n     * const snapshot = await snapshotSource.getSnapshot();\n     * ```\n     */\n    async wrap(identity) {\n        this.wire.sendAction('snapshot-source-wrap').catch((e) => {\n            // don't expose, analytics-only call\n        });\n        return this.wrapSync(identity);\n    }\n}\nFactory.SnapshotSourceModule = SnapshotSourceModule;\n\n(function (exports) {\n\t/**\n\t * Entry points for the OpenFin `SnapshotSource` API (`fin.SnapshotSource`).\n\t *\n\t * * {@link SnapshotSourceModule} contains static members of the `SnapshotSource` API, accessible through `fin.SnapshotSource`.\n\t * * {@link SnapshotSource} describes an instance of an OpenFin SnapshotSource, e.g. as returned by `fin.SnapshotSource.wrap`.\n\t *\n\t * These are separate code entities, and are documented separately.  In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/32.114.76.10/index.html),\n\t * both of these were documented on the same page.\n\t *\n\t * @packageDocumentation\n\t */\n\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t    }\n\t    Object.defineProperty(o, k2, desc);\n\t}) : (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    o[k2] = m[k];\n\t}));\n\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t};\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t__exportStar(Factory, exports);\n\t__exportStar(Instance, exports); \n} (snapshotSource));\n\nObject.defineProperty(fin$2, \"__esModule\", { value: true });\nvar Fin_1 = fin$2.Fin = void 0;\nconst events_1$3 = require$$0;\n// Import from the file rather than the directory in case someone consuming types is using module resolution other than \"node\"\nconst index_1 = system;\nconst index_2 = requireWindow();\nconst index_3 = requireApplication();\nconst index_4 = interappbus;\nconst index_5 = clipboard;\nconst index_6 = externalApplication;\nconst index_7 = frame;\nconst index_8 = globalHotkey;\nconst index_9 = requireView();\nconst index_10 = platform;\nconst me_1$2 = me;\nconst interop_1 = requireInterop();\nconst snapshot_source_1 = snapshotSource;\n/**\n * @internal\n */\nclass Fin extends events_1$3.EventEmitter {\n    /**\n     * @internal\n     */\n    constructor(wire) {\n        super();\n        this.wire = wire;\n        this.System = new index_1.System(wire);\n        this.Window = new index_2._WindowModule(wire);\n        this.Application = new index_3.ApplicationModule(wire);\n        this.InterApplicationBus = new index_4.InterApplicationBus(wire);\n        this.Clipboard = new index_5.Clipboard(wire);\n        this.ExternalApplication = new index_6.ExternalApplicationModule(wire);\n        this.Frame = new index_7._FrameModule(wire);\n        this.GlobalHotkey = new index_8.GlobalHotkey(wire);\n        this.Platform = new index_10.PlatformModule(wire, this.InterApplicationBus.Channel);\n        this.View = new index_9.ViewModule(wire);\n        this.Interop = new interop_1.InteropModule(wire);\n        this.SnapshotSource = new snapshot_source_1.SnapshotSourceModule(wire);\n        wire.registerFin(this);\n        this.me = (0, me_1$2.getMe)(wire);\n        // Handle disconnect events\n        wire.on('disconnected', () => {\n            this.emit('disconnected');\n        });\n    }\n}\nFin_1 = fin$2.Fin = Fin;\n\nvar transport = {};\n\nvar wire = {};\n\nObject.defineProperty(wire, \"__esModule\", { value: true });\nwire.isInternalConnectConfig = wire.isPortDiscoveryConfig = wire.isNewConnectConfig = wire.isConfigWithReceiver = wire.isRemoteConfig = wire.isExistingConnectConfig = wire.isExternalConfig = void 0;\nfunction isExternalConfig(config) {\n    if (typeof config.manifestUrl === 'string') {\n        return true;\n    }\n    return false;\n}\nwire.isExternalConfig = isExternalConfig;\nfunction isExistingConnectConfig(config) {\n    return hasUuid(config) && typeof config.address === 'string';\n}\nwire.isExistingConnectConfig = isExistingConnectConfig;\nfunction isRemoteConfig(config) {\n    return isExistingConnectConfig(config) && typeof config.token === 'string';\n}\nwire.isRemoteConfig = isRemoteConfig;\nfunction isConfigWithReceiver(config) {\n    return typeof config.receiver === 'object' && isRemoteConfig({ ...config, address: '' });\n}\nwire.isConfigWithReceiver = isConfigWithReceiver;\nfunction hasUuid(config) {\n    return typeof config.uuid === 'string';\n}\nfunction hasRuntimeVersion(config) {\n    return config.runtime && typeof config.runtime.version === 'string';\n}\nfunction isNewConnectConfig(config) {\n    return hasUuid(config) && hasRuntimeVersion(config);\n}\nwire.isNewConnectConfig = isNewConnectConfig;\nfunction isPortDiscoveryConfig(config) {\n    return (isExternalConfig(config) && hasRuntimeVersion(config)) || isNewConnectConfig(config);\n}\nwire.isPortDiscoveryConfig = isPortDiscoveryConfig;\nfunction isInternalConnectConfig(config) {\n    return isExistingConnectConfig(config) || isNewConnectConfig(config);\n}\nwire.isInternalConnectConfig = isInternalConnectConfig;\n\nvar eventAggregator = {};\n\nvar emitterMap = {};\n\nObject.defineProperty(emitterMap, \"__esModule\", { value: true });\nemitterMap.EmitterMap = void 0;\nconst events_1$2 = require$$0;\nclass EmitterMap {\n    constructor() {\n        this.storage = new Map();\n    }\n    // eslint-disable-next-line class-methods-use-this\n    hashKeys(keys) {\n        const hashed = keys.map(normalizeString);\n        return hashed.join('/');\n    }\n    getOrCreate(keys) {\n        const hash = this.hashKeys(keys);\n        if (!this.storage.has(hash)) {\n            this.storage.set(hash, new events_1$2.EventEmitter());\n        }\n        // We set it above\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        return this.storage.get(hash);\n    }\n    has(keys) {\n        return this.storage.has(this.hashKeys(keys));\n    }\n    delete(keys) {\n        const hash = this.hashKeys(keys);\n        return this.storage.delete(hash);\n    }\n}\nemitterMap.EmitterMap = EmitterMap;\nfunction normalizeString(s) {\n    const b = Buffer.from(s);\n    return b.toString('base64');\n}\n\nObject.defineProperty(eventAggregator, \"__esModule\", { value: true });\nconst emitterMap_1 = emitterMap;\nfunction isEventMessage(message) {\n    return message.action === 'process-desktop-event';\n}\nfunction mapKeyFromEvent(event) {\n    const { topic } = event;\n    if (topic === 'frame' || topic === 'window' || topic === 'view') {\n        const { uuid, name } = event;\n        return [topic, uuid, name];\n    }\n    if (topic === 'application') {\n        const { uuid } = event;\n        return [topic, uuid];\n    }\n    return [topic];\n}\nclass EventAggregator extends emitterMap_1.EmitterMap {\n    constructor() {\n        super(...arguments);\n        this.dispatchEvent = (message) => {\n            if (isEventMessage(message)) {\n                const { payload } = message;\n                const accessor = mapKeyFromEvent(payload);\n                if (this.has(accessor)) {\n                    this.getOrCreate(accessor).emit(payload.type, payload);\n                    return true;\n                }\n            }\n            return false;\n        };\n    }\n}\neventAggregator.default = EventAggregator;\n\nvar __classPrivateFieldSet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar __classPrivateFieldGet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nvar _Transport_wire, _Transport_fin;\nObject.defineProperty(transport, \"__esModule\", { value: true });\nvar Transport_1 = transport.Transport = void 0;\nconst events_1$1 = require$$0;\nconst wire_1 = wire;\nconst transport_errors_1 = transportErrors;\nconst eventAggregator_1 = __importDefault(eventAggregator);\nconst me_1$1 = me;\nconst errors_1 = errors;\nclass Transport extends events_1$1.EventEmitter {\n    constructor(WireType, environment, config) {\n        super();\n        this.wireListeners = new Map();\n        this.topicRefMap = new Map();\n        this.eventAggregator = new eventAggregator_1.default();\n        this.messageHandlers = [this.eventAggregator.dispatchEvent];\n        _Transport_wire.set(this, void 0);\n        // Typing as unknown to avoid circular dependency, should not be used directly.\n        _Transport_fin.set(this, void 0);\n        this.connectSync = () => {\n            const wire = __classPrivateFieldGet(this, _Transport_wire, \"f\");\n            wire.connectSync();\n        };\n        // This function is only used in our tests.\n        this.getPort = () => {\n            const wire = __classPrivateFieldGet(this, _Transport_wire, \"f\");\n            return wire.getPort();\n        };\n        __classPrivateFieldSet(this, _Transport_wire, new WireType(this.onmessage.bind(this)), \"f\");\n        this.environment = environment;\n        this.sendRaw = __classPrivateFieldGet(this, _Transport_wire, \"f\").send.bind(__classPrivateFieldGet(this, _Transport_wire, \"f\"));\n        this.registerMessageHandler(this.handleMessage.bind(this));\n        __classPrivateFieldGet(this, _Transport_wire, \"f\").on('disconnected', () => {\n            for (const [, { handleNack }] of this.wireListeners) {\n                handleNack({ reason: 'Remote connection has closed' });\n            }\n            this.wireListeners.clear();\n            this.emit('disconnected');\n        });\n        const { uuid, name } = config;\n        const entityType = this.environment.getCurrentEntityType();\n        this.me = (0, me_1$1.getBaseMe)(entityType, uuid, name);\n    }\n    getFin() {\n        if (!__classPrivateFieldGet(this, _Transport_fin, \"f\")) {\n            throw new Error('No Fin object registered for this transport');\n        }\n        return __classPrivateFieldGet(this, _Transport_fin, \"f\");\n    }\n    registerFin(_fin) {\n        if (__classPrivateFieldGet(this, _Transport_fin, \"f\")) {\n            throw new Error('Fin object has already been registered for this transport');\n        }\n        __classPrivateFieldSet(this, _Transport_fin, _fin, \"f\");\n    }\n    shutdown() {\n        const wire = __classPrivateFieldGet(this, _Transport_wire, \"f\");\n        return wire.shutdown();\n    }\n    async connect(config) {\n        if ((0, wire_1.isConfigWithReceiver)(config)) {\n            await __classPrivateFieldGet(this, _Transport_wire, \"f\").connect(config.receiver);\n            return this.authorize(config);\n        }\n        if ((0, wire_1.isRemoteConfig)(config)) {\n            return this.connectRemote(config);\n        }\n        if ((0, wire_1.isExistingConnectConfig)(config)) {\n            return this.connectByPort(config);\n        }\n        if ((0, wire_1.isNewConnectConfig)(config)) {\n            const port = await this.environment.retrievePort(config);\n            return this.connectByPort({ ...config, address: `ws://localhost:${port}` });\n        }\n        return undefined;\n    }\n    async connectRemote(config) {\n        await __classPrivateFieldGet(this, _Transport_wire, \"f\").connect(new (this.environment.getWsConstructor())(config.address));\n        return this.authorize(config);\n    }\n    async connectByPort(config) {\n        const { address, uuid } = config;\n        const reqAuthPayload = { ...config, type: 'file-token' };\n        const wire = __classPrivateFieldGet(this, _Transport_wire, \"f\");\n        await wire.connect(new (this.environment.getWsConstructor())(config.address));\n        const requestExtAuthRet = await this.sendAction('request-external-authorization', {\n            uuid,\n            type: 'file-token'\n        }, true);\n        if (requestExtAuthRet.action !== 'external-authorization-response') {\n            throw new transport_errors_1.UnexpectedActionError(requestExtAuthRet.action);\n        }\n        await this.environment.writeToken(requestExtAuthRet.payload.file, requestExtAuthRet.payload.token);\n        return this.authorize(reqAuthPayload);\n    }\n    async authorize(reqAuthPayload) {\n        const requestAuthRet = await this.sendAction('request-authorization', reqAuthPayload, true);\n        if (requestAuthRet.action !== 'authorization-response') {\n            throw new transport_errors_1.UnexpectedActionError(requestAuthRet.action);\n        }\n        else if (requestAuthRet.payload.success !== true) {\n            throw new transport_errors_1.RuntimeError(requestAuthRet.payload);\n        }\n    }\n    sendAction(action, payload = {}, uncorrelated = false\n    // specialResponse type is only used for 'requestAuthorization'\n    ) {\n        // eslint-disable-next-line @typescript-eslint/no-empty-function\n        let cancel = () => { };\n        // We want the callsite from the caller of this function, not from here.\n        const callSites = transport_errors_1.RuntimeError.getCallSite(1);\n        const messageId = this.environment.getNextMessageId();\n        const prom = new Promise((resolve, reject) => {\n            cancel = reject;\n            const msg = {\n                action,\n                payload,\n                messageId\n            };\n            const wire = __classPrivateFieldGet(this, _Transport_wire, \"f\");\n            this.addWireListener(messageId, resolve, (payload) => this.nackHandler(payload, reject, callSites), uncorrelated);\n            return wire.send(msg).catch(reject);\n        });\n        return Object.assign(prom, { cancel, messageId });\n    }\n    nackHandler(payloadOrMessage, reject, callSites) {\n        if (typeof payloadOrMessage === 'string') {\n            // NOTE: this is for backwards compatibility to support plain string rejections\n            reject(payloadOrMessage);\n        }\n        else {\n            reject(new transport_errors_1.RuntimeError(payloadOrMessage, callSites));\n        }\n    }\n    ferryAction(origData) {\n        return new Promise((resolve, reject) => {\n            const id = this.environment.getNextMessageId();\n            origData.messageId = id;\n            const resolver = (data) => {\n                resolve(data.payload);\n            };\n            const wire = __classPrivateFieldGet(this, _Transport_wire, \"f\");\n            return wire\n                .send(origData)\n                .then(() => this.addWireListener(id, resolver, (payload) => this.nackHandler(payload, reject), false))\n                .catch(reject);\n        });\n    }\n    registerMessageHandler(handler) {\n        this.messageHandlers.push(handler);\n    }\n    addWireListener(id, resolve, handleNack, uncorrelated) {\n        if (uncorrelated) {\n            this.uncorrelatedListener = resolve;\n        }\n        else if (this.wireListeners.has(id)) {\n            handleNack({\n                reason: 'Duplicate handler id',\n                error: (0, errors_1.errorToPOJO)(new transport_errors_1.DuplicateCorrelationError(String(id)))\n            });\n        }\n        else {\n            this.wireListeners.set(id, { resolve, handleNack });\n        }\n        // Timeout and reject()?\n    }\n    // This method executes message handlers until the _one_ that handles the message (returns truthy) has run\n    onmessage(data) {\n        for (const h of this.messageHandlers) {\n            h.call(null, data);\n        }\n    }\n    handleMessage(data) {\n        const id = data.correlationId || NaN;\n        if (!('correlationId' in data)) {\n            if (this.uncorrelatedListener) {\n                this.uncorrelatedListener.call(null, data);\n            }\n            this.uncorrelatedListener = () => {\n                // empty block\n            };\n        }\n        else if (!this.wireListeners.has(id)) {\n            return false;\n        }\n        else {\n            // We just checked for existence above\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            const { resolve, handleNack } = this.wireListeners.get(id);\n            if (data.action !== 'ack') {\n                handleNack({ reason: 'Did not receive ack action', error: (0, errors_1.errorToPOJO)(new transport_errors_1.NoAckError(data.action)) });\n            }\n            else if (!('payload' in data)) {\n                // I'm not sure when this code would actually run, but passing in something that doeesn't have a reason to the runtimeerror constructor will not end well.\n                // @ts-expect-error\n                if (typeof data.reason === 'string') {\n                    handleNack(data);\n                }\n                else {\n                    console.warn('Received invalid response from core', data);\n                    handleNack({ reason: 'invalid response shape' });\n                }\n            }\n            else if (!data.payload.success) {\n                handleNack(data.payload);\n            }\n            else {\n                resolve.call(null, data);\n            }\n            this.wireListeners.delete(id);\n        }\n        return true;\n    }\n}\nTransport_1 = transport.Transport = Transport;\n_Transport_wire = new WeakMap(), _Transport_fin = new WeakMap();\n\nvar mockEnvironment = {};\n\nObject.defineProperty(mockEnvironment, \"__esModule\", { value: true });\nvar MockEnvironment_1 = mockEnvironment.MockEnvironment = void 0;\nconst me_1 = me;\nclass MockEnvironment {\n    constructor() {\n        this.type = 'other';\n        this.childViews = true;\n    }\n    getAdapterVersionSync() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    async getInteropInfo() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    getDefaultChannelOptions() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    getRtcPeer() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    layoutAllowedInContext(_fin) {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    initLayoutManager() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    applyLayoutSnapshot() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    async createLayout() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    async destroyLayout() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    async resolveLayout() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    initPlatform() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    observeBounds() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    writeToken(path, token) {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    retrievePort(config) {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    getNextMessageId() {\n        return `mock-message-id-${Math.random()}`;\n    }\n    getRandomId() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    createChildContent(options) {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    getWebWindow(identity) {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    getCurrentEntityIdentity() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    getCurrentEntityType() {\n        return 'unknown';\n    }\n    raiseEvent(eventName, eventArgs) {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    getUrl() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    whenReady() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    getWsConstructor() {\n        throw new Error('Method not implemented.');\n    }\n}\nMockEnvironment_1 = mockEnvironment.MockEnvironment = MockEnvironment;\n\nvar mockWire = {};\n\nObject.defineProperty(mockWire, \"__esModule\", { value: true });\nvar MockWire_1 = mockWire.MockWire = void 0;\n/* eslint-disable @typescript-eslint/no-unused-vars */\nconst events_1 = require$$0;\nclass MockWire extends events_1.EventEmitter {\n    connect() {\n        throw new Error('You are not running in OpenFin.');\n    }\n    connectSync() {\n        throw new Error('You are not running in OpenFin.');\n    }\n    send(data) {\n        throw new Error('You are not running in OpenFin.');\n    }\n    shutdown() {\n        throw new Error('You are not running in OpenFin.');\n    }\n    getPort() {\n        throw new Error('This transport has no port');\n    }\n    // eslint-disable-next-line no-useless-constructor\n    constructor() {\n        super();\n    }\n}\nMockWire_1 = mockWire.MockWire = MockWire;\n\nconst fin$1 = ((typeof window !== 'undefined' && window?.fin) ||\n    (() => {\n        const environment = new MockEnvironment_1();\n        const transport = new Transport_1(MockWire_1, environment, {\n            uuid: '',\n            name: ''\n        });\n        return new Fin_1(transport);\n    })());\n\nexports.OpenFin = OpenFin$1;\nexports.default = OpenFin$1;\nexports.fin = fin$1;\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar R = typeof Reflect === 'object' ? Reflect : null\nvar ReflectApply = R && typeof R.apply === 'function'\n  ? R.apply\n  : function ReflectApply(target, receiver, args) {\n    return Function.prototype.apply.call(target, receiver, args);\n  }\n\nvar ReflectOwnKeys\nif (R && typeof R.ownKeys === 'function') {\n  ReflectOwnKeys = R.ownKeys\n} else if (Object.getOwnPropertySymbols) {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target)\n      .concat(Object.getOwnPropertySymbols(target));\n  };\n} else {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target);\n  };\n}\n\nfunction ProcessEmitWarning(warning) {\n  if (console && console.warn) console.warn(warning);\n}\n\nvar NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {\n  return value !== value;\n}\n\nfunction EventEmitter() {\n  EventEmitter.init.call(this);\n}\nmodule.exports = EventEmitter;\nmodule.exports.once = once;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._eventsCount = 0;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nvar defaultMaxListeners = 10;\n\nfunction checkListener(listener) {\n  if (typeof listener !== 'function') {\n    throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n  }\n}\n\nObject.defineProperty(EventEmitter, 'defaultMaxListeners', {\n  enumerable: true,\n  get: function() {\n    return defaultMaxListeners;\n  },\n  set: function(arg) {\n    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {\n      throw new RangeError('The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received ' + arg + '.');\n    }\n    defaultMaxListeners = arg;\n  }\n});\n\nEventEmitter.init = function() {\n\n  if (this._events === undefined ||\n      this._events === Object.getPrototypeOf(this)._events) {\n    this._events = Object.create(null);\n    this._eventsCount = 0;\n  }\n\n  this._maxListeners = this._maxListeners || undefined;\n};\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {\n    throw new RangeError('The value of \"n\" is out of range. It must be a non-negative number. Received ' + n + '.');\n  }\n  this._maxListeners = n;\n  return this;\n};\n\nfunction _getMaxListeners(that) {\n  if (that._maxListeners === undefined)\n    return EventEmitter.defaultMaxListeners;\n  return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n  return _getMaxListeners(this);\n};\n\nEventEmitter.prototype.emit = function emit(type) {\n  var args = [];\n  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);\n  var doError = (type === 'error');\n\n  var events = this._events;\n  if (events !== undefined)\n    doError = (doError && events.error === undefined);\n  else if (!doError)\n    return false;\n\n  // If there is no 'error' event listener then throw.\n  if (doError) {\n    var er;\n    if (args.length > 0)\n      er = args[0];\n    if (er instanceof Error) {\n      // Note: The comments on the `throw` lines are intentional, they show\n      // up in Node's output if this results in an unhandled exception.\n      throw er; // Unhandled 'error' event\n    }\n    // At least give some kind of context to the user\n    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));\n    err.context = er;\n    throw err; // Unhandled 'error' event\n  }\n\n  var handler = events[type];\n\n  if (handler === undefined)\n    return false;\n\n  if (typeof handler === 'function') {\n    ReflectApply(handler, this, args);\n  } else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      ReflectApply(listeners[i], this, args);\n  }\n\n  return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n  var m;\n  var events;\n  var existing;\n\n  checkListener(listener);\n\n  events = target._events;\n  if (events === undefined) {\n    events = target._events = Object.create(null);\n    target._eventsCount = 0;\n  } else {\n    // To avoid recursion in the case that type === \"newListener\"! Before\n    // adding it to the listeners, first emit \"newListener\".\n    if (events.newListener !== undefined) {\n      target.emit('newListener', type,\n                  listener.listener ? listener.listener : listener);\n\n      // Re-assign `events` because a newListener handler could have caused the\n      // this._events to be assigned to a new object\n      events = target._events;\n    }\n    existing = events[type];\n  }\n\n  if (existing === undefined) {\n    // Optimize the case of one listener. Don't need the extra array object.\n    existing = events[type] = listener;\n    ++target._eventsCount;\n  } else {\n    if (typeof existing === 'function') {\n      // Adding the second element, need to change to array.\n      existing = events[type] =\n        prepend ? [listener, existing] : [existing, listener];\n      // If we've already got an array, just append.\n    } else if (prepend) {\n      existing.unshift(listener);\n    } else {\n      existing.push(listener);\n    }\n\n    // Check for listener leak\n    m = _getMaxListeners(target);\n    if (m > 0 && existing.length > m && !existing.warned) {\n      existing.warned = true;\n      // No error code for this since it is a Warning\n      // eslint-disable-next-line no-restricted-syntax\n      var w = new Error('Possible EventEmitter memory leak detected. ' +\n                          existing.length + ' ' + String(type) + ' listeners ' +\n                          'added. Use emitter.setMaxListeners() to ' +\n                          'increase limit');\n      w.name = 'MaxListenersExceededWarning';\n      w.emitter = target;\n      w.type = type;\n      w.count = existing.length;\n      ProcessEmitWarning(w);\n    }\n  }\n\n  return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n  return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener =\n    function prependListener(type, listener) {\n      return _addListener(this, type, listener, true);\n    };\n\nfunction onceWrapper() {\n  if (!this.fired) {\n    this.target.removeListener(this.type, this.wrapFn);\n    this.fired = true;\n    if (arguments.length === 0)\n      return this.listener.call(this.target);\n    return this.listener.apply(this.target, arguments);\n  }\n}\n\nfunction _onceWrap(target, type, listener) {\n  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n  var wrapped = onceWrapper.bind(state);\n  wrapped.listener = listener;\n  state.wrapFn = wrapped;\n  return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n  checkListener(listener);\n  this.on(type, _onceWrap(this, type, listener));\n  return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n    function prependOnceListener(type, listener) {\n      checkListener(listener);\n      this.prependListener(type, _onceWrap(this, type, listener));\n      return this;\n    };\n\n// Emits a 'removeListener' event if and only if the listener was removed.\nEventEmitter.prototype.removeListener =\n    function removeListener(type, listener) {\n      var list, events, position, i, originalListener;\n\n      checkListener(listener);\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      list = events[type];\n      if (list === undefined)\n        return this;\n\n      if (list === listener || list.listener === listener) {\n        if (--this._eventsCount === 0)\n          this._events = Object.create(null);\n        else {\n          delete events[type];\n          if (events.removeListener)\n            this.emit('removeListener', type, list.listener || listener);\n        }\n      } else if (typeof list !== 'function') {\n        position = -1;\n\n        for (i = list.length - 1; i >= 0; i--) {\n          if (list[i] === listener || list[i].listener === listener) {\n            originalListener = list[i].listener;\n            position = i;\n            break;\n          }\n        }\n\n        if (position < 0)\n          return this;\n\n        if (position === 0)\n          list.shift();\n        else {\n          spliceOne(list, position);\n        }\n\n        if (list.length === 1)\n          events[type] = list[0];\n\n        if (events.removeListener !== undefined)\n          this.emit('removeListener', type, originalListener || listener);\n      }\n\n      return this;\n    };\n\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\n\nEventEmitter.prototype.removeAllListeners =\n    function removeAllListeners(type) {\n      var listeners, events, i;\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      // not listening for removeListener, no need to emit\n      if (events.removeListener === undefined) {\n        if (arguments.length === 0) {\n          this._events = Object.create(null);\n          this._eventsCount = 0;\n        } else if (events[type] !== undefined) {\n          if (--this._eventsCount === 0)\n            this._events = Object.create(null);\n          else\n            delete events[type];\n        }\n        return this;\n      }\n\n      // emit removeListener for all listeners on all events\n      if (arguments.length === 0) {\n        var keys = Object.keys(events);\n        var key;\n        for (i = 0; i < keys.length; ++i) {\n          key = keys[i];\n          if (key === 'removeListener') continue;\n          this.removeAllListeners(key);\n        }\n        this.removeAllListeners('removeListener');\n        this._events = Object.create(null);\n        this._eventsCount = 0;\n        return this;\n      }\n\n      listeners = events[type];\n\n      if (typeof listeners === 'function') {\n        this.removeListener(type, listeners);\n      } else if (listeners !== undefined) {\n        // LIFO order\n        for (i = listeners.length - 1; i >= 0; i--) {\n          this.removeListener(type, listeners[i]);\n        }\n      }\n\n      return this;\n    };\n\nfunction _listeners(target, type, unwrap) {\n  var events = target._events;\n\n  if (events === undefined)\n    return [];\n\n  var evlistener = events[type];\n  if (evlistener === undefined)\n    return [];\n\n  if (typeof evlistener === 'function')\n    return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n\n  return unwrap ?\n    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n  return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n  return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  if (typeof emitter.listenerCount === 'function') {\n    return emitter.listenerCount(type);\n  } else {\n    return listenerCount.call(emitter, type);\n  }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n  var events = this._events;\n\n  if (events !== undefined) {\n    var evlistener = events[type];\n\n    if (typeof evlistener === 'function') {\n      return 1;\n    } else if (evlistener !== undefined) {\n      return evlistener.length;\n    }\n  }\n\n  return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];\n};\n\nfunction arrayClone(arr, n) {\n  var copy = new Array(n);\n  for (var i = 0; i < n; ++i)\n    copy[i] = arr[i];\n  return copy;\n}\n\nfunction spliceOne(list, index) {\n  for (; index + 1 < list.length; index++)\n    list[index] = list[index + 1];\n  list.pop();\n}\n\nfunction unwrapListeners(arr) {\n  var ret = new Array(arr.length);\n  for (var i = 0; i < ret.length; ++i) {\n    ret[i] = arr[i].listener || arr[i];\n  }\n  return ret;\n}\n\nfunction once(emitter, name) {\n  return new Promise(function (resolve, reject) {\n    function errorListener(err) {\n      emitter.removeListener(name, resolver);\n      reject(err);\n    }\n\n    function resolver() {\n      if (typeof emitter.removeListener === 'function') {\n        emitter.removeListener('error', errorListener);\n      }\n      resolve([].slice.call(arguments));\n    };\n\n    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });\n    if (name !== 'error') {\n      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });\n    }\n  });\n}\n\nfunction addErrorHandlerIfEventEmitter(emitter, handler, flags) {\n  if (typeof emitter.on === 'function') {\n    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);\n  }\n}\n\nfunction eventTargetAgnosticAddListener(emitter, name, listener, flags) {\n  if (typeof emitter.on === 'function') {\n    if (flags.once) {\n      emitter.once(name, listener);\n    } else {\n      emitter.on(name, listener);\n    }\n  } else if (typeof emitter.addEventListener === 'function') {\n    // EventTarget does not have `error` event semantics like Node\n    // EventEmitters, we do not listen for `error` events here.\n    emitter.addEventListener(name, function wrapListener(arg) {\n      // IE does not have builtin `{ once: true }` support so we\n      // have to do it manually.\n      if (flags.once) {\n        emitter.removeEventListener(name, wrapListener);\n      }\n      listener(arg);\n    });\n  } else {\n    throw new TypeError('The \"emitter\" argument must be of type EventEmitter. Received type ' + typeof emitter);\n  }\n}\n","var getNative = require('./_getNative'),\n    root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar DataView = getNative(root, 'DataView');\n\nmodule.exports = DataView;\n","var hashClear = require('./_hashClear'),\n    hashDelete = require('./_hashDelete'),\n    hashGet = require('./_hashGet'),\n    hashHas = require('./_hashHas'),\n    hashSet = require('./_hashSet');\n\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Hash(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\nmodule.exports = Hash;\n","var listCacheClear = require('./_listCacheClear'),\n    listCacheDelete = require('./_listCacheDelete'),\n    listCacheGet = require('./_listCacheGet'),\n    listCacheHas = require('./_listCacheHas'),\n    listCacheSet = require('./_listCacheSet');\n\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction ListCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\nmodule.exports = ListCache;\n","var getNative = require('./_getNative'),\n    root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar Map = getNative(root, 'Map');\n\nmodule.exports = Map;\n","var mapCacheClear = require('./_mapCacheClear'),\n    mapCacheDelete = require('./_mapCacheDelete'),\n    mapCacheGet = require('./_mapCacheGet'),\n    mapCacheHas = require('./_mapCacheHas'),\n    mapCacheSet = require('./_mapCacheSet');\n\n/**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction MapCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\nmodule.exports = MapCache;\n","var getNative = require('./_getNative'),\n    root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar Promise = getNative(root, 'Promise');\n\nmodule.exports = Promise;\n","var getNative = require('./_getNative'),\n    root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar Set = getNative(root, 'Set');\n\nmodule.exports = Set;\n","var MapCache = require('./_MapCache'),\n    setCacheAdd = require('./_setCacheAdd'),\n    setCacheHas = require('./_setCacheHas');\n\n/**\n *\n * Creates an array cache object to store unique values.\n *\n * @private\n * @constructor\n * @param {Array} [values] The values to cache.\n */\nfunction SetCache(values) {\n  var index = -1,\n      length = values == null ? 0 : values.length;\n\n  this.__data__ = new MapCache;\n  while (++index < length) {\n    this.add(values[index]);\n  }\n}\n\n// Add methods to `SetCache`.\nSetCache.prototype.add = SetCache.prototype.push = setCacheAdd;\nSetCache.prototype.has = setCacheHas;\n\nmodule.exports = SetCache;\n","var ListCache = require('./_ListCache'),\n    stackClear = require('./_stackClear'),\n    stackDelete = require('./_stackDelete'),\n    stackGet = require('./_stackGet'),\n    stackHas = require('./_stackHas'),\n    stackSet = require('./_stackSet');\n\n/**\n * Creates a stack cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Stack(entries) {\n  var data = this.__data__ = new ListCache(entries);\n  this.size = data.size;\n}\n\n// Add methods to `Stack`.\nStack.prototype.clear = stackClear;\nStack.prototype['delete'] = stackDelete;\nStack.prototype.get = stackGet;\nStack.prototype.has = stackHas;\nStack.prototype.set = stackSet;\n\nmodule.exports = Stack;\n","var root = require('./_root');\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nmodule.exports = Symbol;\n","var root = require('./_root');\n\n/** Built-in value references. */\nvar Uint8Array = root.Uint8Array;\n\nmodule.exports = Uint8Array;\n","var getNative = require('./_getNative'),\n    root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar WeakMap = getNative(root, 'WeakMap');\n\nmodule.exports = WeakMap;\n","/**\n * A specialized version of `_.forEach` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns `array`.\n */\nfunction arrayEach(array, iteratee) {\n  var index = -1,\n      length = array == null ? 0 : array.length;\n\n  while (++index < length) {\n    if (iteratee(array[index], index, array) === false) {\n      break;\n    }\n  }\n  return array;\n}\n\nmodule.exports = arrayEach;\n","/**\n * A specialized version of `_.filter` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {Array} Returns the new filtered array.\n */\nfunction arrayFilter(array, predicate) {\n  var index = -1,\n      length = array == null ? 0 : array.length,\n      resIndex = 0,\n      result = [];\n\n  while (++index < length) {\n    var value = array[index];\n    if (predicate(value, index, array)) {\n      result[resIndex++] = value;\n    }\n  }\n  return result;\n}\n\nmodule.exports = arrayFilter;\n","var baseTimes = require('./_baseTimes'),\n    isArguments = require('./isArguments'),\n    isArray = require('./isArray'),\n    isBuffer = require('./isBuffer'),\n    isIndex = require('./_isIndex'),\n    isTypedArray = require('./isTypedArray');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n  var isArr = isArray(value),\n      isArg = !isArr && isArguments(value),\n      isBuff = !isArr && !isArg && isBuffer(value),\n      isType = !isArr && !isArg && !isBuff && isTypedArray(value),\n      skipIndexes = isArr || isArg || isBuff || isType,\n      result = skipIndexes ? baseTimes(value.length, String) : [],\n      length = result.length;\n\n  for (var key in value) {\n    if ((inherited || hasOwnProperty.call(value, key)) &&\n        !(skipIndexes && (\n           // Safari 9 has enumerable `arguments.length` in strict mode.\n           key == 'length' ||\n           // Node.js 0.10 has enumerable non-index properties on buffers.\n           (isBuff && (key == 'offset' || key == 'parent')) ||\n           // PhantomJS 2 has enumerable non-index properties on typed arrays.\n           (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||\n           // Skip index properties.\n           isIndex(key, length)\n        ))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nmodule.exports = arrayLikeKeys;\n","/**\n * Appends the elements of `values` to `array`.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to append.\n * @returns {Array} Returns `array`.\n */\nfunction arrayPush(array, values) {\n  var index = -1,\n      length = values.length,\n      offset = array.length;\n\n  while (++index < length) {\n    array[offset + index] = values[index];\n  }\n  return array;\n}\n\nmodule.exports = arrayPush;\n","/**\n * A specialized version of `_.some` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {boolean} Returns `true` if any element passes the predicate check,\n *  else `false`.\n */\nfunction arraySome(array, predicate) {\n  var index = -1,\n      length = array == null ? 0 : array.length;\n\n  while (++index < length) {\n    if (predicate(array[index], index, array)) {\n      return true;\n    }\n  }\n  return false;\n}\n\nmodule.exports = arraySome;\n","var baseAssignValue = require('./_baseAssignValue'),\n    eq = require('./eq');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Assigns `value` to `key` of `object` if the existing value is not equivalent\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignValue(object, key, value) {\n  var objValue = object[key];\n  if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||\n      (value === undefined && !(key in object))) {\n    baseAssignValue(object, key, value);\n  }\n}\n\nmodule.exports = assignValue;\n","var eq = require('./eq');\n\n/**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction assocIndexOf(array, key) {\n  var length = array.length;\n  while (length--) {\n    if (eq(array[length][0], key)) {\n      return length;\n    }\n  }\n  return -1;\n}\n\nmodule.exports = assocIndexOf;\n","var copyObject = require('./_copyObject'),\n    keys = require('./keys');\n\n/**\n * The base implementation of `_.assign` without support for multiple sources\n * or `customizer` functions.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @returns {Object} Returns `object`.\n */\nfunction baseAssign(object, source) {\n  return object && copyObject(source, keys(source), object);\n}\n\nmodule.exports = baseAssign;\n","var copyObject = require('./_copyObject'),\n    keysIn = require('./keysIn');\n\n/**\n * The base implementation of `_.assignIn` without support for multiple sources\n * or `customizer` functions.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @returns {Object} Returns `object`.\n */\nfunction baseAssignIn(object, source) {\n  return object && copyObject(source, keysIn(source), object);\n}\n\nmodule.exports = baseAssignIn;\n","var defineProperty = require('./_defineProperty');\n\n/**\n * The base implementation of `assignValue` and `assignMergeValue` without\n * value checks.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction baseAssignValue(object, key, value) {\n  if (key == '__proto__' && defineProperty) {\n    defineProperty(object, key, {\n      'configurable': true,\n      'enumerable': true,\n      'value': value,\n      'writable': true\n    });\n  } else {\n    object[key] = value;\n  }\n}\n\nmodule.exports = baseAssignValue;\n","var Stack = require('./_Stack'),\n    arrayEach = require('./_arrayEach'),\n    assignValue = require('./_assignValue'),\n    baseAssign = require('./_baseAssign'),\n    baseAssignIn = require('./_baseAssignIn'),\n    cloneBuffer = require('./_cloneBuffer'),\n    copyArray = require('./_copyArray'),\n    copySymbols = require('./_copySymbols'),\n    copySymbolsIn = require('./_copySymbolsIn'),\n    getAllKeys = require('./_getAllKeys'),\n    getAllKeysIn = require('./_getAllKeysIn'),\n    getTag = require('./_getTag'),\n    initCloneArray = require('./_initCloneArray'),\n    initCloneByTag = require('./_initCloneByTag'),\n    initCloneObject = require('./_initCloneObject'),\n    isArray = require('./isArray'),\n    isBuffer = require('./isBuffer'),\n    isMap = require('./isMap'),\n    isObject = require('./isObject'),\n    isSet = require('./isSet'),\n    keys = require('./keys'),\n    keysIn = require('./keysIn');\n\n/** Used to compose bitmasks for cloning. */\nvar CLONE_DEEP_FLAG = 1,\n    CLONE_FLAT_FLAG = 2,\n    CLONE_SYMBOLS_FLAG = 4;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    objectTag = '[object Object]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    symbolTag = '[object Symbol]',\n    weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]',\n    float32Tag = '[object Float32Array]',\n    float64Tag = '[object Float64Array]',\n    int8Tag = '[object Int8Array]',\n    int16Tag = '[object Int16Array]',\n    int32Tag = '[object Int32Array]',\n    uint8Tag = '[object Uint8Array]',\n    uint8ClampedTag = '[object Uint8ClampedArray]',\n    uint16Tag = '[object Uint16Array]',\n    uint32Tag = '[object Uint32Array]';\n\n/** Used to identify `toStringTag` values supported by `_.clone`. */\nvar cloneableTags = {};\ncloneableTags[argsTag] = cloneableTags[arrayTag] =\ncloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =\ncloneableTags[boolTag] = cloneableTags[dateTag] =\ncloneableTags[float32Tag] = cloneableTags[float64Tag] =\ncloneableTags[int8Tag] = cloneableTags[int16Tag] =\ncloneableTags[int32Tag] = cloneableTags[mapTag] =\ncloneableTags[numberTag] = cloneableTags[objectTag] =\ncloneableTags[regexpTag] = cloneableTags[setTag] =\ncloneableTags[stringTag] = cloneableTags[symbolTag] =\ncloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =\ncloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;\ncloneableTags[errorTag] = cloneableTags[funcTag] =\ncloneableTags[weakMapTag] = false;\n\n/**\n * The base implementation of `_.clone` and `_.cloneDeep` which tracks\n * traversed objects.\n *\n * @private\n * @param {*} value The value to clone.\n * @param {boolean} bitmask The bitmask flags.\n *  1 - Deep clone\n *  2 - Flatten inherited properties\n *  4 - Clone symbols\n * @param {Function} [customizer] The function to customize cloning.\n * @param {string} [key] The key of `value`.\n * @param {Object} [object] The parent object of `value`.\n * @param {Object} [stack] Tracks traversed objects and their clone counterparts.\n * @returns {*} Returns the cloned value.\n */\nfunction baseClone(value, bitmask, customizer, key, object, stack) {\n  var result,\n      isDeep = bitmask & CLONE_DEEP_FLAG,\n      isFlat = bitmask & CLONE_FLAT_FLAG,\n      isFull = bitmask & CLONE_SYMBOLS_FLAG;\n\n  if (customizer) {\n    result = object ? customizer(value, key, object, stack) : customizer(value);\n  }\n  if (result !== undefined) {\n    return result;\n  }\n  if (!isObject(value)) {\n    return value;\n  }\n  var isArr = isArray(value);\n  if (isArr) {\n    result = initCloneArray(value);\n    if (!isDeep) {\n      return copyArray(value, result);\n    }\n  } else {\n    var tag = getTag(value),\n        isFunc = tag == funcTag || tag == genTag;\n\n    if (isBuffer(value)) {\n      return cloneBuffer(value, isDeep);\n    }\n    if (tag == objectTag || tag == argsTag || (isFunc && !object)) {\n      result = (isFlat || isFunc) ? {} : initCloneObject(value);\n      if (!isDeep) {\n        return isFlat\n          ? copySymbolsIn(value, baseAssignIn(result, value))\n          : copySymbols(value, baseAssign(result, value));\n      }\n    } else {\n      if (!cloneableTags[tag]) {\n        return object ? value : {};\n      }\n      result = initCloneByTag(value, tag, isDeep);\n    }\n  }\n  // Check for circular references and return its corresponding clone.\n  stack || (stack = new Stack);\n  var stacked = stack.get(value);\n  if (stacked) {\n    return stacked;\n  }\n  stack.set(value, result);\n\n  if (isSet(value)) {\n    value.forEach(function(subValue) {\n      result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));\n    });\n  } else if (isMap(value)) {\n    value.forEach(function(subValue, key) {\n      result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));\n    });\n  }\n\n  var keysFunc = isFull\n    ? (isFlat ? getAllKeysIn : getAllKeys)\n    : (isFlat ? keysIn : keys);\n\n  var props = isArr ? undefined : keysFunc(value);\n  arrayEach(props || value, function(subValue, key) {\n    if (props) {\n      key = subValue;\n      subValue = value[key];\n    }\n    // Recursively populate clone (susceptible to call stack limits).\n    assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));\n  });\n  return result;\n}\n\nmodule.exports = baseClone;\n","var isObject = require('./isObject');\n\n/** Built-in value references. */\nvar objectCreate = Object.create;\n\n/**\n * The base implementation of `_.create` without support for assigning\n * properties to the created object.\n *\n * @private\n * @param {Object} proto The object to inherit from.\n * @returns {Object} Returns the new object.\n */\nvar baseCreate = (function() {\n  function object() {}\n  return function(proto) {\n    if (!isObject(proto)) {\n      return {};\n    }\n    if (objectCreate) {\n      return objectCreate(proto);\n    }\n    object.prototype = proto;\n    var result = new object;\n    object.prototype = undefined;\n    return result;\n  };\n}());\n\nmodule.exports = baseCreate;\n","var arrayPush = require('./_arrayPush'),\n    isArray = require('./isArray');\n\n/**\n * The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @param {Function} symbolsFunc The function to get the symbols of `object`.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction baseGetAllKeys(object, keysFunc, symbolsFunc) {\n  var result = keysFunc(object);\n  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n}\n\nmodule.exports = baseGetAllKeys;\n","var Symbol = require('./_Symbol'),\n    getRawTag = require('./_getRawTag'),\n    objectToString = require('./_objectToString');\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n    undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag && symToStringTag in Object(value))\n    ? getRawTag(value)\n    : objectToString(value);\n}\n\nmodule.exports = baseGetTag;\n","var baseGetTag = require('./_baseGetTag'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]';\n\n/**\n * The base implementation of `_.isArguments`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n */\nfunction baseIsArguments(value) {\n  return isObjectLike(value) && baseGetTag(value) == argsTag;\n}\n\nmodule.exports = baseIsArguments;\n","var baseIsEqualDeep = require('./_baseIsEqualDeep'),\n    isObjectLike = require('./isObjectLike');\n\n/**\n * The base implementation of `_.isEqual` which supports partial comparisons\n * and tracks traversed objects.\n *\n * @private\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @param {boolean} bitmask The bitmask flags.\n *  1 - Unordered comparison\n *  2 - Partial comparison\n * @param {Function} [customizer] The function to customize comparisons.\n * @param {Object} [stack] Tracks traversed `value` and `other` objects.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n */\nfunction baseIsEqual(value, other, bitmask, customizer, stack) {\n  if (value === other) {\n    return true;\n  }\n  if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {\n    return value !== value && other !== other;\n  }\n  return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);\n}\n\nmodule.exports = baseIsEqual;\n","var Stack = require('./_Stack'),\n    equalArrays = require('./_equalArrays'),\n    equalByTag = require('./_equalByTag'),\n    equalObjects = require('./_equalObjects'),\n    getTag = require('./_getTag'),\n    isArray = require('./isArray'),\n    isBuffer = require('./isBuffer'),\n    isTypedArray = require('./isTypedArray');\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    objectTag = '[object Object]';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * A specialized version of `baseIsEqual` for arrays and objects which performs\n * deep comparisons and tracks traversed objects enabling objects with circular\n * references to be compared.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} [stack] Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {\n  var objIsArr = isArray(object),\n      othIsArr = isArray(other),\n      objTag = objIsArr ? arrayTag : getTag(object),\n      othTag = othIsArr ? arrayTag : getTag(other);\n\n  objTag = objTag == argsTag ? objectTag : objTag;\n  othTag = othTag == argsTag ? objectTag : othTag;\n\n  var objIsObj = objTag == objectTag,\n      othIsObj = othTag == objectTag,\n      isSameTag = objTag == othTag;\n\n  if (isSameTag && isBuffer(object)) {\n    if (!isBuffer(other)) {\n      return false;\n    }\n    objIsArr = true;\n    objIsObj = false;\n  }\n  if (isSameTag && !objIsObj) {\n    stack || (stack = new Stack);\n    return (objIsArr || isTypedArray(object))\n      ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)\n      : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);\n  }\n  if (!(bitmask & COMPARE_PARTIAL_FLAG)) {\n    var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),\n        othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');\n\n    if (objIsWrapped || othIsWrapped) {\n      var objUnwrapped = objIsWrapped ? object.value() : object,\n          othUnwrapped = othIsWrapped ? other.value() : other;\n\n      stack || (stack = new Stack);\n      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);\n    }\n  }\n  if (!isSameTag) {\n    return false;\n  }\n  stack || (stack = new Stack);\n  return equalObjects(object, other, bitmask, customizer, equalFunc, stack);\n}\n\nmodule.exports = baseIsEqualDeep;\n","var getTag = require('./_getTag'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar mapTag = '[object Map]';\n\n/**\n * The base implementation of `_.isMap` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a map, else `false`.\n */\nfunction baseIsMap(value) {\n  return isObjectLike(value) && getTag(value) == mapTag;\n}\n\nmodule.exports = baseIsMap;\n","var isFunction = require('./isFunction'),\n    isMasked = require('./_isMasked'),\n    isObject = require('./isObject'),\n    toSource = require('./_toSource');\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n    objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n  .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n *  else `false`.\n */\nfunction baseIsNative(value) {\n  if (!isObject(value) || isMasked(value)) {\n    return false;\n  }\n  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n  return pattern.test(toSource(value));\n}\n\nmodule.exports = baseIsNative;\n","var getTag = require('./_getTag'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar setTag = '[object Set]';\n\n/**\n * The base implementation of `_.isSet` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a set, else `false`.\n */\nfunction baseIsSet(value) {\n  return isObjectLike(value) && getTag(value) == setTag;\n}\n\nmodule.exports = baseIsSet;\n","var baseGetTag = require('./_baseGetTag'),\n    isLength = require('./isLength'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    funcTag = '[object Function]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    objectTag = '[object Object]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]',\n    float32Tag = '[object Float32Array]',\n    float64Tag = '[object Float64Array]',\n    int8Tag = '[object Int8Array]',\n    int16Tag = '[object Int16Array]',\n    int32Tag = '[object Int32Array]',\n    uint8Tag = '[object Uint8Array]',\n    uint8ClampedTag = '[object Uint8ClampedArray]',\n    uint16Tag = '[object Uint16Array]',\n    uint32Tag = '[object Uint32Array]';\n\n/** Used to identify `toStringTag` values of typed arrays. */\nvar typedArrayTags = {};\ntypedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\ntypedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\ntypedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\ntypedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\ntypedArrayTags[uint32Tag] = true;\ntypedArrayTags[argsTag] = typedArrayTags[arrayTag] =\ntypedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\ntypedArrayTags[dataViewTag] = typedArrayTags[dateTag] =\ntypedArrayTags[errorTag] = typedArrayTags[funcTag] =\ntypedArrayTags[mapTag] = typedArrayTags[numberTag] =\ntypedArrayTags[objectTag] = typedArrayTags[regexpTag] =\ntypedArrayTags[setTag] = typedArrayTags[stringTag] =\ntypedArrayTags[weakMapTag] = false;\n\n/**\n * The base implementation of `_.isTypedArray` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n */\nfunction baseIsTypedArray(value) {\n  return isObjectLike(value) &&\n    isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n}\n\nmodule.exports = baseIsTypedArray;\n","var isPrototype = require('./_isPrototype'),\n    nativeKeys = require('./_nativeKeys');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeys(object) {\n  if (!isPrototype(object)) {\n    return nativeKeys(object);\n  }\n  var result = [];\n  for (var key in Object(object)) {\n    if (hasOwnProperty.call(object, key) && key != 'constructor') {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nmodule.exports = baseKeys;\n","var isObject = require('./isObject'),\n    isPrototype = require('./_isPrototype'),\n    nativeKeysIn = require('./_nativeKeysIn');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeysIn(object) {\n  if (!isObject(object)) {\n    return nativeKeysIn(object);\n  }\n  var isProto = isPrototype(object),\n      result = [];\n\n  for (var key in object) {\n    if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nmodule.exports = baseKeysIn;\n","/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n  var index = -1,\n      result = Array(n);\n\n  while (++index < n) {\n    result[index] = iteratee(index);\n  }\n  return result;\n}\n\nmodule.exports = baseTimes;\n","/**\n * The base implementation of `_.unary` without support for storing metadata.\n *\n * @private\n * @param {Function} func The function to cap arguments for.\n * @returns {Function} Returns the new capped function.\n */\nfunction baseUnary(func) {\n  return function(value) {\n    return func(value);\n  };\n}\n\nmodule.exports = baseUnary;\n","/**\n * Checks if a `cache` value for `key` exists.\n *\n * @private\n * @param {Object} cache The cache to query.\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction cacheHas(cache, key) {\n  return cache.has(key);\n}\n\nmodule.exports = cacheHas;\n","var Uint8Array = require('./_Uint8Array');\n\n/**\n * Creates a clone of `arrayBuffer`.\n *\n * @private\n * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n * @returns {ArrayBuffer} Returns the cloned array buffer.\n */\nfunction cloneArrayBuffer(arrayBuffer) {\n  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n  new Uint8Array(result).set(new Uint8Array(arrayBuffer));\n  return result;\n}\n\nmodule.exports = cloneArrayBuffer;\n","var root = require('./_root');\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined,\n    allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined;\n\n/**\n * Creates a clone of  `buffer`.\n *\n * @private\n * @param {Buffer} buffer The buffer to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Buffer} Returns the cloned buffer.\n */\nfunction cloneBuffer(buffer, isDeep) {\n  if (isDeep) {\n    return buffer.slice();\n  }\n  var length = buffer.length,\n      result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);\n\n  buffer.copy(result);\n  return result;\n}\n\nmodule.exports = cloneBuffer;\n","var cloneArrayBuffer = require('./_cloneArrayBuffer');\n\n/**\n * Creates a clone of `dataView`.\n *\n * @private\n * @param {Object} dataView The data view to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned data view.\n */\nfunction cloneDataView(dataView, isDeep) {\n  var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;\n  return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);\n}\n\nmodule.exports = cloneDataView;\n","/** Used to match `RegExp` flags from their coerced string values. */\nvar reFlags = /\\w*$/;\n\n/**\n * Creates a clone of `regexp`.\n *\n * @private\n * @param {Object} regexp The regexp to clone.\n * @returns {Object} Returns the cloned regexp.\n */\nfunction cloneRegExp(regexp) {\n  var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));\n  result.lastIndex = regexp.lastIndex;\n  return result;\n}\n\nmodule.exports = cloneRegExp;\n","var Symbol = require('./_Symbol');\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;\n\n/**\n * Creates a clone of the `symbol` object.\n *\n * @private\n * @param {Object} symbol The symbol object to clone.\n * @returns {Object} Returns the cloned symbol object.\n */\nfunction cloneSymbol(symbol) {\n  return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};\n}\n\nmodule.exports = cloneSymbol;\n","var cloneArrayBuffer = require('./_cloneArrayBuffer');\n\n/**\n * Creates a clone of `typedArray`.\n *\n * @private\n * @param {Object} typedArray The typed array to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned typed array.\n */\nfunction cloneTypedArray(typedArray, isDeep) {\n  var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n}\n\nmodule.exports = cloneTypedArray;\n","/**\n * Copies the values of `source` to `array`.\n *\n * @private\n * @param {Array} source The array to copy values from.\n * @param {Array} [array=[]] The array to copy values to.\n * @returns {Array} Returns `array`.\n */\nfunction copyArray(source, array) {\n  var index = -1,\n      length = source.length;\n\n  array || (array = Array(length));\n  while (++index < length) {\n    array[index] = source[index];\n  }\n  return array;\n}\n\nmodule.exports = copyArray;\n","var assignValue = require('./_assignValue'),\n    baseAssignValue = require('./_baseAssignValue');\n\n/**\n * Copies properties of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property identifiers to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @param {Function} [customizer] The function to customize copied values.\n * @returns {Object} Returns `object`.\n */\nfunction copyObject(source, props, object, customizer) {\n  var isNew = !object;\n  object || (object = {});\n\n  var index = -1,\n      length = props.length;\n\n  while (++index < length) {\n    var key = props[index];\n\n    var newValue = customizer\n      ? customizer(object[key], source[key], key, object, source)\n      : undefined;\n\n    if (newValue === undefined) {\n      newValue = source[key];\n    }\n    if (isNew) {\n      baseAssignValue(object, key, newValue);\n    } else {\n      assignValue(object, key, newValue);\n    }\n  }\n  return object;\n}\n\nmodule.exports = copyObject;\n","var copyObject = require('./_copyObject'),\n    getSymbols = require('./_getSymbols');\n\n/**\n * Copies own symbols of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy symbols from.\n * @param {Object} [object={}] The object to copy symbols to.\n * @returns {Object} Returns `object`.\n */\nfunction copySymbols(source, object) {\n  return copyObject(source, getSymbols(source), object);\n}\n\nmodule.exports = copySymbols;\n","var copyObject = require('./_copyObject'),\n    getSymbolsIn = require('./_getSymbolsIn');\n\n/**\n * Copies own and inherited symbols of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy symbols from.\n * @param {Object} [object={}] The object to copy symbols to.\n * @returns {Object} Returns `object`.\n */\nfunction copySymbolsIn(source, object) {\n  return copyObject(source, getSymbolsIn(source), object);\n}\n\nmodule.exports = copySymbolsIn;\n","var root = require('./_root');\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\nmodule.exports = coreJsData;\n","var getNative = require('./_getNative');\n\nvar defineProperty = (function() {\n  try {\n    var func = getNative(Object, 'defineProperty');\n    func({}, '', {});\n    return func;\n  } catch (e) {}\n}());\n\nmodule.exports = defineProperty;\n","var SetCache = require('./_SetCache'),\n    arraySome = require('./_arraySome'),\n    cacheHas = require('./_cacheHas');\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n    COMPARE_UNORDERED_FLAG = 2;\n\n/**\n * A specialized version of `baseIsEqualDeep` for arrays with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Array} array The array to compare.\n * @param {Array} other The other array to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `array` and `other` objects.\n * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.\n */\nfunction equalArrays(array, other, bitmask, customizer, equalFunc, stack) {\n  var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n      arrLength = array.length,\n      othLength = other.length;\n\n  if (arrLength != othLength && !(isPartial && othLength > arrLength)) {\n    return false;\n  }\n  // Check that cyclic values are equal.\n  var arrStacked = stack.get(array);\n  var othStacked = stack.get(other);\n  if (arrStacked && othStacked) {\n    return arrStacked == other && othStacked == array;\n  }\n  var index = -1,\n      result = true,\n      seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;\n\n  stack.set(array, other);\n  stack.set(other, array);\n\n  // Ignore non-index properties.\n  while (++index < arrLength) {\n    var arrValue = array[index],\n        othValue = other[index];\n\n    if (customizer) {\n      var compared = isPartial\n        ? customizer(othValue, arrValue, index, other, array, stack)\n        : customizer(arrValue, othValue, index, array, other, stack);\n    }\n    if (compared !== undefined) {\n      if (compared) {\n        continue;\n      }\n      result = false;\n      break;\n    }\n    // Recursively compare arrays (susceptible to call stack limits).\n    if (seen) {\n      if (!arraySome(other, function(othValue, othIndex) {\n            if (!cacheHas(seen, othIndex) &&\n                (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {\n              return seen.push(othIndex);\n            }\n          })) {\n        result = false;\n        break;\n      }\n    } else if (!(\n          arrValue === othValue ||\n            equalFunc(arrValue, othValue, bitmask, customizer, stack)\n        )) {\n      result = false;\n      break;\n    }\n  }\n  stack['delete'](array);\n  stack['delete'](other);\n  return result;\n}\n\nmodule.exports = equalArrays;\n","var Symbol = require('./_Symbol'),\n    Uint8Array = require('./_Uint8Array'),\n    eq = require('./eq'),\n    equalArrays = require('./_equalArrays'),\n    mapToArray = require('./_mapToArray'),\n    setToArray = require('./_setToArray');\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n    COMPARE_UNORDERED_FLAG = 2;\n\n/** `Object#toString` result references. */\nvar boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    symbolTag = '[object Symbol]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]';\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;\n\n/**\n * A specialized version of `baseIsEqualDeep` for comparing objects of\n * the same `toStringTag`.\n *\n * **Note:** This function only supports comparing values with tags of\n * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {string} tag The `toStringTag` of the objects to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {\n  switch (tag) {\n    case dataViewTag:\n      if ((object.byteLength != other.byteLength) ||\n          (object.byteOffset != other.byteOffset)) {\n        return false;\n      }\n      object = object.buffer;\n      other = other.buffer;\n\n    case arrayBufferTag:\n      if ((object.byteLength != other.byteLength) ||\n          !equalFunc(new Uint8Array(object), new Uint8Array(other))) {\n        return false;\n      }\n      return true;\n\n    case boolTag:\n    case dateTag:\n    case numberTag:\n      // Coerce booleans to `1` or `0` and dates to milliseconds.\n      // Invalid dates are coerced to `NaN`.\n      return eq(+object, +other);\n\n    case errorTag:\n      return object.name == other.name && object.message == other.message;\n\n    case regexpTag:\n    case stringTag:\n      // Coerce regexes to strings and treat strings, primitives and objects,\n      // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring\n      // for more details.\n      return object == (other + '');\n\n    case mapTag:\n      var convert = mapToArray;\n\n    case setTag:\n      var isPartial = bitmask & COMPARE_PARTIAL_FLAG;\n      convert || (convert = setToArray);\n\n      if (object.size != other.size && !isPartial) {\n        return false;\n      }\n      // Assume cyclic values are equal.\n      var stacked = stack.get(object);\n      if (stacked) {\n        return stacked == other;\n      }\n      bitmask |= COMPARE_UNORDERED_FLAG;\n\n      // Recursively compare objects (susceptible to call stack limits).\n      stack.set(object, other);\n      var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);\n      stack['delete'](object);\n      return result;\n\n    case symbolTag:\n      if (symbolValueOf) {\n        return symbolValueOf.call(object) == symbolValueOf.call(other);\n      }\n  }\n  return false;\n}\n\nmodule.exports = equalByTag;\n","var getAllKeys = require('./_getAllKeys');\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1;\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * A specialized version of `baseIsEqualDeep` for objects with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction equalObjects(object, other, bitmask, customizer, equalFunc, stack) {\n  var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n      objProps = getAllKeys(object),\n      objLength = objProps.length,\n      othProps = getAllKeys(other),\n      othLength = othProps.length;\n\n  if (objLength != othLength && !isPartial) {\n    return false;\n  }\n  var index = objLength;\n  while (index--) {\n    var key = objProps[index];\n    if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {\n      return false;\n    }\n  }\n  // Check that cyclic values are equal.\n  var objStacked = stack.get(object);\n  var othStacked = stack.get(other);\n  if (objStacked && othStacked) {\n    return objStacked == other && othStacked == object;\n  }\n  var result = true;\n  stack.set(object, other);\n  stack.set(other, object);\n\n  var skipCtor = isPartial;\n  while (++index < objLength) {\n    key = objProps[index];\n    var objValue = object[key],\n        othValue = other[key];\n\n    if (customizer) {\n      var compared = isPartial\n        ? customizer(othValue, objValue, key, other, object, stack)\n        : customizer(objValue, othValue, key, object, other, stack);\n    }\n    // Recursively compare objects (susceptible to call stack limits).\n    if (!(compared === undefined\n          ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))\n          : compared\n        )) {\n      result = false;\n      break;\n    }\n    skipCtor || (skipCtor = key == 'constructor');\n  }\n  if (result && !skipCtor) {\n    var objCtor = object.constructor,\n        othCtor = other.constructor;\n\n    // Non `Object` object instances with different constructors are not equal.\n    if (objCtor != othCtor &&\n        ('constructor' in object && 'constructor' in other) &&\n        !(typeof objCtor == 'function' && objCtor instanceof objCtor &&\n          typeof othCtor == 'function' && othCtor instanceof othCtor)) {\n      result = false;\n    }\n  }\n  stack['delete'](object);\n  stack['delete'](other);\n  return result;\n}\n\nmodule.exports = equalObjects;\n","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nmodule.exports = freeGlobal;\n","var baseGetAllKeys = require('./_baseGetAllKeys'),\n    getSymbols = require('./_getSymbols'),\n    keys = require('./keys');\n\n/**\n * Creates an array of own enumerable property names and symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction getAllKeys(object) {\n  return baseGetAllKeys(object, keys, getSymbols);\n}\n\nmodule.exports = getAllKeys;\n","var baseGetAllKeys = require('./_baseGetAllKeys'),\n    getSymbolsIn = require('./_getSymbolsIn'),\n    keysIn = require('./keysIn');\n\n/**\n * Creates an array of own and inherited enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction getAllKeysIn(object) {\n  return baseGetAllKeys(object, keysIn, getSymbolsIn);\n}\n\nmodule.exports = getAllKeysIn;\n","var isKeyable = require('./_isKeyable');\n\n/**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\nfunction getMapData(map, key) {\n  var data = map.__data__;\n  return isKeyable(key)\n    ? data[typeof key == 'string' ? 'string' : 'hash']\n    : data.map;\n}\n\nmodule.exports = getMapData;\n","var baseIsNative = require('./_baseIsNative'),\n    getValue = require('./_getValue');\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n  var value = getValue(object, key);\n  return baseIsNative(value) ? value : undefined;\n}\n\nmodule.exports = getNative;\n","var overArg = require('./_overArg');\n\n/** Built-in value references. */\nvar getPrototype = overArg(Object.getPrototypeOf, Object);\n\nmodule.exports = getPrototype;\n","var Symbol = require('./_Symbol');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\nmodule.exports = getRawTag;\n","var arrayFilter = require('./_arrayFilter'),\n    stubArray = require('./stubArray');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeGetSymbols = Object.getOwnPropertySymbols;\n\n/**\n * Creates an array of the own enumerable symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\nvar getSymbols = !nativeGetSymbols ? stubArray : function(object) {\n  if (object == null) {\n    return [];\n  }\n  object = Object(object);\n  return arrayFilter(nativeGetSymbols(object), function(symbol) {\n    return propertyIsEnumerable.call(object, symbol);\n  });\n};\n\nmodule.exports = getSymbols;\n","var arrayPush = require('./_arrayPush'),\n    getPrototype = require('./_getPrototype'),\n    getSymbols = require('./_getSymbols'),\n    stubArray = require('./stubArray');\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeGetSymbols = Object.getOwnPropertySymbols;\n\n/**\n * Creates an array of the own and inherited enumerable symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\nvar getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {\n  var result = [];\n  while (object) {\n    arrayPush(result, getSymbols(object));\n    object = getPrototype(object);\n  }\n  return result;\n};\n\nmodule.exports = getSymbolsIn;\n","var DataView = require('./_DataView'),\n    Map = require('./_Map'),\n    Promise = require('./_Promise'),\n    Set = require('./_Set'),\n    WeakMap = require('./_WeakMap'),\n    baseGetTag = require('./_baseGetTag'),\n    toSource = require('./_toSource');\n\n/** `Object#toString` result references. */\nvar mapTag = '[object Map]',\n    objectTag = '[object Object]',\n    promiseTag = '[object Promise]',\n    setTag = '[object Set]',\n    weakMapTag = '[object WeakMap]';\n\nvar dataViewTag = '[object DataView]';\n\n/** Used to detect maps, sets, and weakmaps. */\nvar dataViewCtorString = toSource(DataView),\n    mapCtorString = toSource(Map),\n    promiseCtorString = toSource(Promise),\n    setCtorString = toSource(Set),\n    weakMapCtorString = toSource(WeakMap);\n\n/**\n * Gets the `toStringTag` of `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nvar getTag = baseGetTag;\n\n// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.\nif ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||\n    (Map && getTag(new Map) != mapTag) ||\n    (Promise && getTag(Promise.resolve()) != promiseTag) ||\n    (Set && getTag(new Set) != setTag) ||\n    (WeakMap && getTag(new WeakMap) != weakMapTag)) {\n  getTag = function(value) {\n    var result = baseGetTag(value),\n        Ctor = result == objectTag ? value.constructor : undefined,\n        ctorString = Ctor ? toSource(Ctor) : '';\n\n    if (ctorString) {\n      switch (ctorString) {\n        case dataViewCtorString: return dataViewTag;\n        case mapCtorString: return mapTag;\n        case promiseCtorString: return promiseTag;\n        case setCtorString: return setTag;\n        case weakMapCtorString: return weakMapTag;\n      }\n    }\n    return result;\n  };\n}\n\nmodule.exports = getTag;\n","/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue(object, key) {\n  return object == null ? undefined : object[key];\n}\n\nmodule.exports = getValue;\n","var nativeCreate = require('./_nativeCreate');\n\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\nfunction hashClear() {\n  this.__data__ = nativeCreate ? nativeCreate(null) : {};\n  this.size = 0;\n}\n\nmodule.exports = hashClear;\n","/**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction hashDelete(key) {\n  var result = this.has(key) && delete this.__data__[key];\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\nmodule.exports = hashDelete;\n","var nativeCreate = require('./_nativeCreate');\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction hashGet(key) {\n  var data = this.__data__;\n  if (nativeCreate) {\n    var result = data[key];\n    return result === HASH_UNDEFINED ? undefined : result;\n  }\n  return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n\nmodule.exports = hashGet;\n","var nativeCreate = require('./_nativeCreate');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction hashHas(key) {\n  var data = this.__data__;\n  return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);\n}\n\nmodule.exports = hashHas;\n","var nativeCreate = require('./_nativeCreate');\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\nfunction hashSet(key, value) {\n  var data = this.__data__;\n  this.size += this.has(key) ? 0 : 1;\n  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n  return this;\n}\n\nmodule.exports = hashSet;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Initializes an array clone.\n *\n * @private\n * @param {Array} array The array to clone.\n * @returns {Array} Returns the initialized clone.\n */\nfunction initCloneArray(array) {\n  var length = array.length,\n      result = new array.constructor(length);\n\n  // Add properties assigned by `RegExp#exec`.\n  if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {\n    result.index = array.index;\n    result.input = array.input;\n  }\n  return result;\n}\n\nmodule.exports = initCloneArray;\n","var cloneArrayBuffer = require('./_cloneArrayBuffer'),\n    cloneDataView = require('./_cloneDataView'),\n    cloneRegExp = require('./_cloneRegExp'),\n    cloneSymbol = require('./_cloneSymbol'),\n    cloneTypedArray = require('./_cloneTypedArray');\n\n/** `Object#toString` result references. */\nvar boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    symbolTag = '[object Symbol]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]',\n    float32Tag = '[object Float32Array]',\n    float64Tag = '[object Float64Array]',\n    int8Tag = '[object Int8Array]',\n    int16Tag = '[object Int16Array]',\n    int32Tag = '[object Int32Array]',\n    uint8Tag = '[object Uint8Array]',\n    uint8ClampedTag = '[object Uint8ClampedArray]',\n    uint16Tag = '[object Uint16Array]',\n    uint32Tag = '[object Uint32Array]';\n\n/**\n * Initializes an object clone based on its `toStringTag`.\n *\n * **Note:** This function only supports cloning values with tags of\n * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`.\n *\n * @private\n * @param {Object} object The object to clone.\n * @param {string} tag The `toStringTag` of the object to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the initialized clone.\n */\nfunction initCloneByTag(object, tag, isDeep) {\n  var Ctor = object.constructor;\n  switch (tag) {\n    case arrayBufferTag:\n      return cloneArrayBuffer(object);\n\n    case boolTag:\n    case dateTag:\n      return new Ctor(+object);\n\n    case dataViewTag:\n      return cloneDataView(object, isDeep);\n\n    case float32Tag: case float64Tag:\n    case int8Tag: case int16Tag: case int32Tag:\n    case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:\n      return cloneTypedArray(object, isDeep);\n\n    case mapTag:\n      return new Ctor;\n\n    case numberTag:\n    case stringTag:\n      return new Ctor(object);\n\n    case regexpTag:\n      return cloneRegExp(object);\n\n    case setTag:\n      return new Ctor;\n\n    case symbolTag:\n      return cloneSymbol(object);\n  }\n}\n\nmodule.exports = initCloneByTag;\n","var baseCreate = require('./_baseCreate'),\n    getPrototype = require('./_getPrototype'),\n    isPrototype = require('./_isPrototype');\n\n/**\n * Initializes an object clone.\n *\n * @private\n * @param {Object} object The object to clone.\n * @returns {Object} Returns the initialized clone.\n */\nfunction initCloneObject(object) {\n  return (typeof object.constructor == 'function' && !isPrototype(object))\n    ? baseCreate(getPrototype(object))\n    : {};\n}\n\nmodule.exports = initCloneObject;\n","/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n  var type = typeof value;\n  length = length == null ? MAX_SAFE_INTEGER : length;\n\n  return !!length &&\n    (type == 'number' ||\n      (type != 'symbol' && reIsUint.test(value))) &&\n        (value > -1 && value % 1 == 0 && value < length);\n}\n\nmodule.exports = isIndex;\n","/**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\nfunction isKeyable(value) {\n  var type = typeof value;\n  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n    ? (value !== '__proto__')\n    : (value === null);\n}\n\nmodule.exports = isKeyable;\n","var coreJsData = require('./_coreJsData');\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = (function() {\n  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n  return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n  return !!maskSrcKey && (maskSrcKey in func);\n}\n\nmodule.exports = isMasked;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n  var Ctor = value && value.constructor,\n      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n  return value === proto;\n}\n\nmodule.exports = isPrototype;\n","/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\nfunction listCacheClear() {\n  this.__data__ = [];\n  this.size = 0;\n}\n\nmodule.exports = listCacheClear;\n","var assocIndexOf = require('./_assocIndexOf');\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype;\n\n/** Built-in value references. */\nvar splice = arrayProto.splice;\n\n/**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction listCacheDelete(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    return false;\n  }\n  var lastIndex = data.length - 1;\n  if (index == lastIndex) {\n    data.pop();\n  } else {\n    splice.call(data, index, 1);\n  }\n  --this.size;\n  return true;\n}\n\nmodule.exports = listCacheDelete;\n","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction listCacheGet(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  return index < 0 ? undefined : data[index][1];\n}\n\nmodule.exports = listCacheGet;\n","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction listCacheHas(key) {\n  return assocIndexOf(this.__data__, key) > -1;\n}\n\nmodule.exports = listCacheHas;\n","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\nfunction listCacheSet(key, value) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    ++this.size;\n    data.push([key, value]);\n  } else {\n    data[index][1] = value;\n  }\n  return this;\n}\n\nmodule.exports = listCacheSet;\n","var Hash = require('./_Hash'),\n    ListCache = require('./_ListCache'),\n    Map = require('./_Map');\n\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\nfunction mapCacheClear() {\n  this.size = 0;\n  this.__data__ = {\n    'hash': new Hash,\n    'map': new (Map || ListCache),\n    'string': new Hash\n  };\n}\n\nmodule.exports = mapCacheClear;\n","var getMapData = require('./_getMapData');\n\n/**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction mapCacheDelete(key) {\n  var result = getMapData(this, key)['delete'](key);\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\nmodule.exports = mapCacheDelete;\n","var getMapData = require('./_getMapData');\n\n/**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction mapCacheGet(key) {\n  return getMapData(this, key).get(key);\n}\n\nmodule.exports = mapCacheGet;\n","var getMapData = require('./_getMapData');\n\n/**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction mapCacheHas(key) {\n  return getMapData(this, key).has(key);\n}\n\nmodule.exports = mapCacheHas;\n","var getMapData = require('./_getMapData');\n\n/**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\nfunction mapCacheSet(key, value) {\n  var data = getMapData(this, key),\n      size = data.size;\n\n  data.set(key, value);\n  this.size += data.size == size ? 0 : 1;\n  return this;\n}\n\nmodule.exports = mapCacheSet;\n","/**\n * Converts `map` to its key-value pairs.\n *\n * @private\n * @param {Object} map The map to convert.\n * @returns {Array} Returns the key-value pairs.\n */\nfunction mapToArray(map) {\n  var index = -1,\n      result = Array(map.size);\n\n  map.forEach(function(value, key) {\n    result[++index] = [key, value];\n  });\n  return result;\n}\n\nmodule.exports = mapToArray;\n","var getNative = require('./_getNative');\n\n/* Built-in method references that are verified to be native. */\nvar nativeCreate = getNative(Object, 'create');\n\nmodule.exports = nativeCreate;\n","var overArg = require('./_overArg');\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeKeys = overArg(Object.keys, Object);\n\nmodule.exports = nativeKeys;\n","/**\n * This function is like\n * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * except that it includes inherited enumerable properties.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction nativeKeysIn(object) {\n  var result = [];\n  if (object != null) {\n    for (var key in Object(object)) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nmodule.exports = nativeKeysIn;\n","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Detect free variable `process` from Node.js. */\nvar freeProcess = moduleExports && freeGlobal.process;\n\n/** Used to access faster Node.js helpers. */\nvar nodeUtil = (function() {\n  try {\n    // Use `util.types` for Node.js 10+.\n    var types = freeModule && freeModule.require && freeModule.require('util').types;\n\n    if (types) {\n      return types;\n    }\n\n    // Legacy `process.binding('util')` for Node.js < 10.\n    return freeProcess && freeProcess.binding && freeProcess.binding('util');\n  } catch (e) {}\n}());\n\nmodule.exports = nodeUtil;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n\nmodule.exports = objectToString;\n","/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n  return function(arg) {\n    return func(transform(arg));\n  };\n}\n\nmodule.exports = overArg;\n","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nmodule.exports = root;\n","/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/**\n * Adds `value` to the array cache.\n *\n * @private\n * @name add\n * @memberOf SetCache\n * @alias push\n * @param {*} value The value to cache.\n * @returns {Object} Returns the cache instance.\n */\nfunction setCacheAdd(value) {\n  this.__data__.set(value, HASH_UNDEFINED);\n  return this;\n}\n\nmodule.exports = setCacheAdd;\n","/**\n * Checks if `value` is in the array cache.\n *\n * @private\n * @name has\n * @memberOf SetCache\n * @param {*} value The value to search for.\n * @returns {number} Returns `true` if `value` is found, else `false`.\n */\nfunction setCacheHas(value) {\n  return this.__data__.has(value);\n}\n\nmodule.exports = setCacheHas;\n","/**\n * Converts `set` to an array of its values.\n *\n * @private\n * @param {Object} set The set to convert.\n * @returns {Array} Returns the values.\n */\nfunction setToArray(set) {\n  var index = -1,\n      result = Array(set.size);\n\n  set.forEach(function(value) {\n    result[++index] = value;\n  });\n  return result;\n}\n\nmodule.exports = setToArray;\n","var ListCache = require('./_ListCache');\n\n/**\n * Removes all key-value entries from the stack.\n *\n * @private\n * @name clear\n * @memberOf Stack\n */\nfunction stackClear() {\n  this.__data__ = new ListCache;\n  this.size = 0;\n}\n\nmodule.exports = stackClear;\n","/**\n * Removes `key` and its value from the stack.\n *\n * @private\n * @name delete\n * @memberOf Stack\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction stackDelete(key) {\n  var data = this.__data__,\n      result = data['delete'](key);\n\n  this.size = data.size;\n  return result;\n}\n\nmodule.exports = stackDelete;\n","/**\n * Gets the stack value for `key`.\n *\n * @private\n * @name get\n * @memberOf Stack\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction stackGet(key) {\n  return this.__data__.get(key);\n}\n\nmodule.exports = stackGet;\n","/**\n * Checks if a stack value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Stack\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction stackHas(key) {\n  return this.__data__.has(key);\n}\n\nmodule.exports = stackHas;\n","var ListCache = require('./_ListCache'),\n    Map = require('./_Map'),\n    MapCache = require('./_MapCache');\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/**\n * Sets the stack `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Stack\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the stack cache instance.\n */\nfunction stackSet(key, value) {\n  var data = this.__data__;\n  if (data instanceof ListCache) {\n    var pairs = data.__data__;\n    if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n      pairs.push([key, value]);\n      this.size = ++data.size;\n      return this;\n    }\n    data = this.__data__ = new MapCache(pairs);\n  }\n  data.set(key, value);\n  this.size = data.size;\n  return this;\n}\n\nmodule.exports = stackSet;\n","/** Used for built-in method references. */\nvar funcProto = Function.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to convert.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n  if (func != null) {\n    try {\n      return funcToString.call(func);\n    } catch (e) {}\n    try {\n      return (func + '');\n    } catch (e) {}\n  }\n  return '';\n}\n\nmodule.exports = toSource;\n","var baseClone = require('./_baseClone');\n\n/** Used to compose bitmasks for cloning. */\nvar CLONE_DEEP_FLAG = 1,\n    CLONE_SYMBOLS_FLAG = 4;\n\n/**\n * This method is like `_.clone` except that it recursively clones `value`.\n *\n * @static\n * @memberOf _\n * @since 1.0.0\n * @category Lang\n * @param {*} value The value to recursively clone.\n * @returns {*} Returns the deep cloned value.\n * @see _.clone\n * @example\n *\n * var objects = [{ 'a': 1 }, { 'b': 2 }];\n *\n * var deep = _.cloneDeep(objects);\n * console.log(deep[0] === objects[0]);\n * // => false\n */\nfunction cloneDeep(value) {\n  return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);\n}\n\nmodule.exports = cloneDeep;\n","/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n  return value === other || (value !== value && other !== other);\n}\n\nmodule.exports = eq;\n","var baseIsArguments = require('./_baseIsArguments'),\n    isObjectLike = require('./isObjectLike');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n *  else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nvar isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\n  return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&\n    !propertyIsEnumerable.call(value, 'callee');\n};\n\nmodule.exports = isArguments;\n","/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\nmodule.exports = isArray;\n","var isFunction = require('./isFunction'),\n    isLength = require('./isLength');\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n  return value != null && isLength(value.length) && !isFunction(value);\n}\n\nmodule.exports = isArrayLike;\n","var root = require('./_root'),\n    stubFalse = require('./stubFalse');\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;\n\n/**\n * Checks if `value` is a buffer.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n *\n * _.isBuffer(new Buffer(2));\n * // => true\n *\n * _.isBuffer(new Uint8Array(2));\n * // => false\n */\nvar isBuffer = nativeIsBuffer || stubFalse;\n\nmodule.exports = isBuffer;\n","var baseIsEqual = require('./_baseIsEqual');\n\n/**\n * Performs a deep comparison between two values to determine if they are\n * equivalent.\n *\n * **Note:** This method supports comparing arrays, array buffers, booleans,\n * date objects, error objects, maps, numbers, `Object` objects, regexes,\n * sets, strings, symbols, and typed arrays. `Object` objects are compared\n * by their own, not inherited, enumerable properties. Functions and DOM\n * nodes are compared by strict equality, i.e. `===`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.isEqual(object, other);\n * // => true\n *\n * object === other;\n * // => false\n */\nfunction isEqual(value, other) {\n  return baseIsEqual(value, other);\n}\n\nmodule.exports = isEqual;\n","var baseGetTag = require('./_baseGetTag'),\n    isObject = require('./isObject');\n\n/** `Object#toString` result references. */\nvar asyncTag = '[object AsyncFunction]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    proxyTag = '[object Proxy]';\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  if (!isObject(value)) {\n    return false;\n  }\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 9 which returns 'object' for typed arrays and other constructors.\n  var tag = baseGetTag(value);\n  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n}\n\nmodule.exports = isFunction;\n","/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n  return typeof value == 'number' &&\n    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\nmodule.exports = isLength;\n","var baseIsMap = require('./_baseIsMap'),\n    baseUnary = require('./_baseUnary'),\n    nodeUtil = require('./_nodeUtil');\n\n/* Node.js helper references. */\nvar nodeIsMap = nodeUtil && nodeUtil.isMap;\n\n/**\n * Checks if `value` is classified as a `Map` object.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a map, else `false`.\n * @example\n *\n * _.isMap(new Map);\n * // => true\n *\n * _.isMap(new WeakMap);\n * // => false\n */\nvar isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;\n\nmodule.exports = isMap;\n","/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return value != null && (type == 'object' || type == 'function');\n}\n\nmodule.exports = isObject;\n","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\nmodule.exports = isObjectLike;\n","var baseIsSet = require('./_baseIsSet'),\n    baseUnary = require('./_baseUnary'),\n    nodeUtil = require('./_nodeUtil');\n\n/* Node.js helper references. */\nvar nodeIsSet = nodeUtil && nodeUtil.isSet;\n\n/**\n * Checks if `value` is classified as a `Set` object.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a set, else `false`.\n * @example\n *\n * _.isSet(new Set);\n * // => true\n *\n * _.isSet(new WeakSet);\n * // => false\n */\nvar isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;\n\nmodule.exports = isSet;\n","var baseIsTypedArray = require('./_baseIsTypedArray'),\n    baseUnary = require('./_baseUnary'),\n    nodeUtil = require('./_nodeUtil');\n\n/* Node.js helper references. */\nvar nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n\n/**\n * Checks if `value` is classified as a typed array.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n * @example\n *\n * _.isTypedArray(new Uint8Array);\n * // => true\n *\n * _.isTypedArray([]);\n * // => false\n */\nvar isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\nmodule.exports = isTypedArray;\n","var arrayLikeKeys = require('./_arrayLikeKeys'),\n    baseKeys = require('./_baseKeys'),\n    isArrayLike = require('./isArrayLike');\n\n/**\n * Creates an array of the own enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * for more details.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keys(new Foo);\n * // => ['a', 'b'] (iteration order is not guaranteed)\n *\n * _.keys('hi');\n * // => ['0', '1']\n */\nfunction keys(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n}\n\nmodule.exports = keys;\n","var arrayLikeKeys = require('./_arrayLikeKeys'),\n    baseKeysIn = require('./_baseKeysIn'),\n    isArrayLike = require('./isArrayLike');\n\n/**\n * Creates an array of the own and inherited enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keysIn(new Foo);\n * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n */\nfunction keysIn(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);\n}\n\nmodule.exports = keysIn;\n","/**\n * This method returns a new empty array.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {Array} Returns the new empty array.\n * @example\n *\n * var arrays = _.times(2, _.stubArray);\n *\n * console.log(arrays);\n * // => [[], []]\n *\n * console.log(arrays[0] === arrays[1]);\n * // => false\n */\nfunction stubArray() {\n  return [];\n}\n\nmodule.exports = stubArray;\n","/**\n * This method returns `false`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n *\n * _.times(2, _.stubFalse);\n * // => [false, false]\n */\nfunction stubFalse() {\n  return false;\n}\n\nmodule.exports = stubFalse;\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\tid: moduleId,\n\t\tloaded: false,\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Flag the module as loaded\n\tmodule.loaded = true;\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","__webpack_require__.nmd = (module) => {\n\tmodule.paths = [];\n\tif (!module.children) module.children = [];\n\treturn module;\n};","import type OpenFin from \"@openfin/core\";\nimport { fin } from \"@openfin/core\";\n\nlet fileName: string;\nlet debugLogStr: string;\nlet debugLogFile: File;\n\ndocument.addEventListener(\"DOMContentLoaded\", async () => {\n\ttry {\n\t\tawait initDom();\n\t} catch (error) {\n\t\tconsole.error(error);\n\t}\n});\n\n/**\n * Populates DOM with the UI elements and adds listeners obtaining selected/submitted options.\n */\nasync function initDom(): Promise<void> {\n\tconst logListElement = document.querySelector<HTMLSelectElement>(\"#log-list\");\n\tif (logListElement) {\n\t\tawait createLogDropDown(logListElement);\n\t\tlogListElement.addEventListener(\"change\", async (selectionChangeEvent) => {\n\t\t\tfileName = (selectionChangeEvent.target as HTMLOptionElement).value;\n\t\t});\n\t}\n\n\tconst upload = document.querySelector<HTMLFormElement>(\"#upload-form\");\n\tif (upload) {\n\t\tupload.addEventListener(\"submit\", uploadHandler);\n\t}\n\tconst sendAppLogBtn = document.querySelector<HTMLButtonElement>(\"#send-app-log\");\n\tif (sendAppLogBtn) {\n\t\tsendAppLogBtn.addEventListener(\"click\", sendApplicationLogs);\n\t}\n}\n\n/**\n * Handle uploads.\n * 1. Creates a FormData object.\n * 2. Creates a File object from the string of the Runtime debug log file contents.\n * 3. Populates the FormData object with necessary parameters to be read by the server.\n * 4. Uploads the created runtime debug log file to a server endpoint.\n * @param submitEvent The event to handle.\n */\nasync function uploadHandler(submitEvent: Event): Promise<void> {\n\tsubmitEvent.preventDefault();\n\tif (!fileName) {\n\t\tfileName = \"debug.log\";\n\t}\n\tconst formData = new FormData();\n\tdebugLogStr = await getLogFromName(fileName);\n\tdebugLogFile = new File([debugLogStr], fileName, { type: \"text/plain\" });\n\tformData.append(\"file\", debugLogFile);\n\tformData.append(\"filename\", fileName);\n\tformData.append(\"uuid\", fin.me.uuid);\n\tconst uploadState = await fetch(\"http://localhost:5050/uploads\", {\n\t\tmethod: \"POST\",\n\t\tbody: formData\n\t});\n\n\tconst uploadStateJson = await uploadState.json();\n\tconst uploadStateJsonString = JSON.stringify(uploadStateJson, null, 5);\n\tconst logs = `${new Date().toLocaleTimeString()}: ${uploadStateJsonString}\\n`;\n\tconst logPreview = document.querySelector(\"#preview\");\n\tif (logPreview) {\n\t\tlogPreview.textContent += logs;\n\t}\n}\n\n/**\n * Sends a message to the OpenFin RVM to send the application logs.\n */\nasync function sendApplicationLogs(): Promise<void> {\n\ttry {\n\t\tconst appLogResponse = await fin.Application.getCurrentSync().sendApplicationLog();\n\t\tconsole.log(`Log ID: ${appLogResponse.logId}`);\n\t} catch {\n\t\t// swallow unnecessary errors.\n\t}\n}\n\n/**\n * Retrieves the runtime debug log from a filename.\n * @param name file name of the runtime debug log to retrieve.\n * @returns the log content.\n */\nasync function getLogFromName(name: string): Promise<string> {\n\tconst log = await fin.System.getLog({ name });\n\treturn log;\n}\n\n/**\n * Creates an HTMLOptionElement for each of the Runtime debug logs.\n * @param parentElement HTML Element to append the log filename HTMLOptionElement to.\n */\nasync function createLogDropDown(parentElement: HTMLSelectElement): Promise<void> {\n\tconst logList: OpenFin.LogInfo[] = await fin.System.getLogList();\n\n\tfor (const log of logList) {\n\t\tconst logElement: HTMLOptionElement = document.createElement(\"option\");\n\t\tlogElement.id = log.date;\n\t\tlogElement.textContent = log.name;\n\t\tlogElement.value = log.name;\n\t\tparentElement.append(logElement);\n\t}\n}\n"],"names":[],"sourceRoot":""}
\ No newline at end of file
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"app.bundle.js","mappings":";;;;;;;;;;AAAa;;AAEb,8CAA6C,EAAE,aAAa,EAAC;;AAE7D,iBAAiB,mBAAO,CAAC,mDAAQ;AACjC,mBAAmB,mBAAO,CAAC,gEAAkB;AAC7C,iBAAiB,mBAAO,CAAC,4DAAgB;;AAEzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB;AACxB,KAAK;AACL;AACA,GAAG;AACH,EAAE;AACF;AACA;;AAEA,sHAAsH,qBAAM,mBAAmB,qBAAM;;AAErJ;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;AACA,mDAAmD,0BAA0B;AAC7E,2BAA2B,sBAAsB,qBAAqB,mBAAmB;AACzF;AACA;AACA;AACA;AACA,2DAA2D,cAAc;AACzE;AACA;AACA,UAAU,8BAA8B,KAAK,0BAA0B,oBAAoB,4BAA4B;AACvH,IAAI,0BAA0B,gFAAgF,oCAAoC;AAClJ;AACA,IAAI,0DAA0D,2CAA2C;AACzG,OAAO,oCAAoC,iBAAiB,mCAAmC;AAC/F,IAAI;AACJ;AACA;AACA,6BAA6B,wBAAwB;AACrD;AACA;AACA;AACA,qDAAqD,aAAa;;AAElE;;AAEA;AACA;AACA;AACA;AACA;AACA,8CAA8C,aAAa;;AAE3D;;AAEA;AACA,uDAAuD,kCAAkC;AACzF;AACA;AACA;AACA,2DAA2D,cAAc;AACzE;AACA,yEAAyE,oDAAoD;AAC7H;AACA;AACA;AACA,6DAA6D,aAAa;;AAE1E;;AAEA,+CAA+C,aAAa;;AAE5D;;AAEA;AACA;AACA,oDAAoD,gCAAgC;AACpF;AACA;AACA;AACA,2DAA2D,cAAc;AACzE;AACA,kEAAkE,mDAAmD;AACrH;AACA;AACA;AACA,sDAAsD,aAAa;;AAEnE;;AAEA;AACA;AACA,+CAA+C,uBAAuB;AACtE;AACA;AACA;AACA,2DAA2D,cAAc;AACzE;AACA,qDAAqD,2BAA2B;AAChF,iCAAiC,oDAAoD;AACrF;AACA,IAAI,8BAA8B;AAClC;AACA;AACA;AACA,kDAAkD,aAAa;;AAE/D;;AAEA;AACA,yDAAyD,oBAAoB;AAC7E,uBAAuB,0BAA0B,GAAG,qBAAqB,OAAO,oBAAoB;AACpG;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2DAA2D,cAAc;AACzE;AACA;AACA,UAAU,uCAAuC,GAAG,6BAA6B,OAAO,0BAA0B;AAClH,IAAI,gCAAgC,GAAG,2BAA2B,OAAO,0BAA0B;AACnG,uBAAuB,0BAA0B;AACjD;AACA;AACA;AACA,gDAAgD,aAAa;;AAE7D;;AAEA;AACA,kDAAkD,mBAAmB;AACrE;AACA;AACA;AACA,2DAA2D,cAAc;AACzE;AACA;AACA,UAAU,qBAAqB,GAAG,mBAAmB,kBAAkB,gCAAgC;AACvG,oDAAoD,sBAAsB;AAC1E;AACA,0CAA0C,kCAAkC,GAAG,4CAA4C;AAC3H,QAAQ,mCAAmC;AAC3C;AACA;AACA;AACA,8CAA8C,aAAa;;AAE3D;;AAEA;AACA,0EAA0E,qBAAqB;AAC/F,IAAI,mBAAmB;AACvB;AACA;AACA,kGAAkG,0BAA0B;AAC5H;AACA;AACA;AACA,mDAAmD,aAAa;;AAEhE;;AAEA;AACA,kDAAkD,qBAAqB;AACvE;AACA;AACA;AACA,2DAA2D,cAAc;AACzE;AACA;AACA,UAAU,qBAAqB,GAAG,mBAAmB,kBAAkB,gCAAgC;AACvG,yCAAyC,yBAAyB;AAClE,IAAI;AACJ;AACA,IAAI,qEAAqE;AACzE,IAAI,8BAA8B,6BAA6B,6CAA6C;AAC5G,IAAI,mCAAmC;AACvC;AACA,6BAA6B,yBAAyB,qCAAqC;AAC3F;AACA;AACA;AACA;AACA,gDAAgD,aAAa;;AAE7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,0BAA0B,GAAG;AACnC,MAAM,kCAAkC,GAAG;AAC3C,MAAM,oBAAoB,GAAG;AAC7B,MAAM,2BAA2B,GAAG;AACpC,MAAM,uBAAuB,GAAG;AAChC,MAAM,qBAAqB,GAAG;AAC9B,MAAM,mBAAmB,GAAG;AAC5B,MAAM,qBAAqB,GAAG;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU,2BAA2B;AACrC,MAAM,+BAA+B,uCAAuC,2BAA2B;AACvG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,oCAAoC;AACnD;AACA;AACA,CAAC;AACD;AACA;AACA,CAAC;AACD;AACA,0CAA0C,4BAA4B;AACtE,CAAC;AACD;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C,aAAa;AAC3D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,iDAAiD,aAAa;AAC9D,kFAAkF,wBAAwB;AAC1G,+DAA+D,kBAAkB;AACjF,8CAA8C,yBAAyB;AACvE,sDAAsD,yBAAyB,KAAK,uBAAuB;AAC3G;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,oCAAoC;AACpD;AACA;AACA,EAAE;AACF;AACA;AACA,EAAE;AACF;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA,EAAE;;AAEF;;AAEA;AACA;AACA;AACA,CAAC;;AAED;;AAEA;;AAEA;;AAEA;;AAEA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4CAA4C,aAAa;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,oBAAoB,IAAI,qBAAqB;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mEAAmE;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qEAAqE;AACrE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,sBAAsB;AAC5E;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,sBAAsB;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,sDAAsD,sBAAsB;AAC5E;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,sBAAsB;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B;AAC/B;AACA;AACA;AACA;AACA,4BAA4B,cAAc;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,uDAAuD,aAAa;AACpE;AACA;AACA;AACA,yDAAyD,WAAW;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,gCAAgC;AAChD;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD;AACrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,kBAAkB;AACzC;AACA,kCAAkC,oBAAoB;AACtD;AACA;AACA;AACA;AACA;AACA,gBAAgB,gBAAgB;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA,qEAAqE,YAAY;AACjF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B;AAC5B,cAAc;AACd;AACA;AACA,yDAAyD,kBAAkB;AAC3E;AACA,gCAAgC,0BAA0B;AAC1D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,4CAA4C;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yCAAyC,wCAAwC;AACjF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,iBAAiB,aAAa;AAC9B,4BAA4B,YAAY;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,iBAAiB,aAAa;AAC9B,gCAAgC,YAAY;AAC5C;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA,4CAA4C,aAAa;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA,mDAAmD,aAAa;AAChE;AACA;AACA,mCAAmC,gBAAgB;AACnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,KAAK;AAClB;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gEAAgE,iBAAiB;AACjF,4DAA4D;AAC5D;AACA;AACA;AACA;AACA,qCAAqC,0BAA0B;AAC/D;AACA;;AAEA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+EAA+E,cAAc;AAC7F;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA,wDAAwD,aAAa;AACrE;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,KAAK;AACzB,oBAAoB,QAAQ,0CAA0C,GAAG;AACzE;AACA;AACA;AACA,oBAAoB,SAAS;AAC7B,mDAAmD,MAAM;AACzD;AACA;AACA;AACA;AACA;;AAEA;;AAEA,uDAAuD,aAAa;AACpE;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,qBAAqB;AACzC,oBAAoB,KAAK;AACzB,8BAA8B,GAAG,GAAG,uBAAuB;AAC3D,yEAAyE,MAAM;AAC/E;AACA,aAAa;AACb,qBAAqB;AACrB;AACA,mCAAmC,IAAI;AACvC,uCAAuC,GAAG;AAC1C,yEAAyE,OAAO;AAChF;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,gBAAgB,oCAAoC;AACpD;AACA;AACA,EAAE;AACF;AACA;AACA,EAAE;AACF;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA,EAAE;;AAEF;AACA;AACA;AACA;AACA;AACA,gBAAgB,oCAAoC;AACpD;AACA;AACA,EAAE;AACF;AACA;AACA,EAAE;AACF;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA,EAAE;;AAEF;AACA;AACA;AACA;AACA;AACA,gBAAgB,oCAAoC;AACpD;AACA;AACA,EAAE;AACF;AACA;AACA,EAAE;AACF;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA,EAAE;;AAEF;;AAEA,uDAAuD,aAAa;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,QAAQ,MAAM,yBAAyB;AAC7E;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA,8CAA8C,QAAQ;AACtD;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,aAAa;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,gCAAgC;AAC9D,qBAAqB,gBAAgB,KAAK,mBAAmB;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gDAAgD,OAAO;AACvD;AACA;AACA;AACA;AACA;AACA,0DAA0D,aAAa;AACvE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C,OAAO;AACpD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,+CAA+C;AAChE,iBAAiB,iEAAiE;AAClF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA,+EAA+E,mBAAmB;AAClG;AACA,wEAAwE,mBAAmB;AAC3F,kEAAkE,iBAAiB;AACnF;AACA;AACA;AACA;AACA;AACA;AACA,0CAA0C,yBAAyB;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yCAAyC,oBAAoB,2BAA2B,mBAAmB;AAC3G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC,4BAA4B;AAChE;AACA;AACA;AACA,+BAA+B,4BAA4B;AAC3D;AACA;AACA;AACA,wFAAwF,UAAU;AAClG,8BAA8B,kBAAkB;AAChD;AACA;AACA,YAAY,iBAAiB;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wEAAwE,2BAA2B;AACnG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B;AAC1B;AACA;AACA;AACA,4FAA4F,gBAAgB,KAAK,kBAAkB;AACnI;AACA;AACA;AACA,4DAA4D,eAAe;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,gBAAgB;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yCAAyC,cAAc;AACvD;AACA;AACA;AACA;AACA;AACA,2CAA2C,eAAe;AAC1D;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC,iCAAiC;AACxE;AACA,2BAA2B,gBAAgB;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4DAA4D,gDAAgD;AAC5G,mEAAmE,oBAAoB;AACvF,wBAAwB,gBAAgB;AACxC,2DAA2D,8CAA8C,IAAI,UAAU;AACvH,kEAAkE,mBAAmB;AACrF;AACA;AACA;AACA,gDAAgD,UAAU;AAC1D;AACA,qCAAqC,eAAe;AACpD;AACA;AACA;AACA;AACA;AACA,2BAA2B,gBAAgB;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4DAA4D,gDAAgD;AAC5G;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC,gBAAgB;AACxD;AACA;AACA,2BAA2B,gBAAgB;AAC3C;AACA;AACA;AACA;AACA,kDAAkD,iCAAiC;AACnF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C,qBAAqB;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,wDAAwD,aAAa;AACrE;AACA;AACA;AACA;;AAEA;;AAEA,4CAA4C,aAAa;AACzD;AACA;AACA;AACA;AACA,4CAA4C,4CAA4C;AACxF,0CAA0C,4CAA4C;AACtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,sDAAsD,2BAA2B,UAAU,SAAS;AACpG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C,gCAAgC;AAC7E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA;AACA,0DAA0D,wBAAwB;AAClF,qBAAqB,SAAS;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,6EAA6E,SAAS;AACtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,wDAAwD,yBAAyB;AACjF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB;AACxB,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,yDAAyD,uBAAuB;AAChF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C,uCAAuC;AACrF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+CAA+C,kCAAkC;AACjF;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,8DAA8D,kBAAkB;AAChF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,gEAAgE,kBAAkB;AAClF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C,uCAAuC;AACrF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+CAA+C,kCAAkC;AACjF;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,gEAAgE,kBAAkB;AAClF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oDAAoD;AACpD;AACA;AACA;AACA;AACA;AACA,oBAAoB,kDAAkD;AACtE;AACA,QAAQ;AACR;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA,sBAAsB;AACtB,+CAA+C,2BAA2B;AAC1E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA;AACA,0CAA0C,uCAAuC;AACjF,qBAAqB,SAAS;AAC9B;AACA;AACA,eAAe,kCAAkC;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ,QAAQ;AACR;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ,QAAQ;AACR;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,2DAA2D,0BAA0B;AACrF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB,YAAY;AACZ;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB,YAAY;AACZ;AACA;AACA,YAAY;AACZ;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,sDAAsD,kBAAkB,UAAU,SAAS;AAC3F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA,kBAAkB,mBAAmB,IAAI,wBAAwB;AACjE,qDAAqD,oCAAoC;AACzF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,gBAAgB,WAAW,SAAS;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB;AACxB,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,iFAAiF,SAAS;AAC1F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB;AACxB,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,8DAA8D,kBAAkB;AAChF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB;AACxB,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,oEAAoE,4BAA4B;AAChG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB;AACxB,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,+DAA+D,kBAAkB;AACjF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA,eAAe,aAAa;AAC5B,eAAe,MAAM;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,gCAAgC,gBAAgB;AAChD;AACA,SAAS;AACT;AACA,2CAA2C,WAAW;AACtD;AACA,mEAAmE,yCAAyC;AAC5G;AACA;AACA;AACA,2FAA2F,MAAM;AACjG;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,4BAA4B;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,SAAS;AACT,gBAAgB,QAAQ,oCAAoC;AAC5D;AACA;AACA;AACA;AACA;AACA,oBAAoB,2BAA2B;AAC/C;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,UAAU;AAC1B;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mDAAmD,aAAa;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,8CAA8C;AACpF;AACA;AACA,sDAAsD,sCAAsC;AAC5F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yDAAyD,0BAA0B;AACnF;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C,oCAAoC;AACjF;AACA;AACA;AACA;AACA;AACA,0DAA0D,kBAAkB;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uDAAuD,kBAAkB;AACzE;AACA;AACA;AACA;AACA;AACA;AACA,cAAc,iBAAiB;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kDAAkD;AAClD,0DAA0D,mCAAmC;AAC7F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iEAAiE,kBAAkB;AACnF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uDAAuD,kBAAkB;AACzE;AACA;AACA;AACA;AACA;AACA,cAAc,iBAAiB;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,0BAA0B;AACvF;AACA;AACA;AACA;AACA;AACA,cAAc,iBAAiB;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA,yEAAyE,kBAAkB;AAC3F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uEAAuE,kBAAkB;AACzF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8DAA8D,kBAAkB;AAChF;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2CAA2C,oDAAoD;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+DAA+D,kBAAkB,UAAU,SAAS;AACpG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qCAAqC;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,2BAA2B;AAC7F;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C,oCAAoC;AACjF;AACA;AACA,gDAAgD;AAChD;AACA;AACA;AACA;AACA,qBAAqB,WAAW,SAAS,kDAAkD,kBAAkB;AAC7G;AACA;AACA;AACA,mCAAmC,wBAAwB;AAC3D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0CAA0C,cAAc;AACxD;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,wDAAwD;AACrH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mFAAmF,kBAAkB;AACrG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yCAAyC,oCAAoC;AAC7E;AACA;AACA;AACA;AACA;AACA,mBAAmB,mBAAmB,IAAI,wBAAwB;AAClE;AACA;AACA,6BAA6B,kBAAkB;AAC/C;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,oCAAoC;AACrD;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA;AACA,iDAAiD,aAAa;AAC9D;AACA;AACA;AACA,QAAQ,kBAAkB;AAC1B,QAAQ,YAAY;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;;AAEA;;AAEA;AACA;AACA;AACA,mDAAmD,aAAa;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,mDAAmD;AAChH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8EAA8E,QAAQ;AACtF;AACA;AACA;AACA,sFAAsF,SAAS;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oEAAoE,IAAI,8BAA8B,GAAG,8BAA8B;AACvI,oDAAoD,aAAa;AACjE;AACA,oEAAoE,IAAI,8BAA8B;AACtG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iEAAiE,yBAAyB;AAC1F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+DAA+D,yBAAyB;AACxF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iFAAiF,SAAS;AAC1F;AACA;AACA,qCAAqC,yCAAyC;AAC9E,cAAc;AACd;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wFAAwF,SAAS;AACjG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sFAAsF,SAAS;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD,iBAAiB;AACtE;AACA;AACA;AACA;AACA;AACA;AACA,6EAA6E,SAAS;AACtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,UAAU;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0FAA0F,SAAS;AACnG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wDAAwD,qCAAqC;AAC7F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C,yBAAyB,oCAAoC,wBAAwB;AACnI;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,mBAAmB;AACnB;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,UAAU;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yCAAyC,QAAQ;AACjD,6CAA6C,SAAS;AACtD;AACA;AACA;AACA,qBAAqB;AACrB,sBAAsB,mBAAmB;AACzC;AACA;AACA,0CAA0C,QAAQ;AAClD;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA,4IAA4I,aAAa;AACzJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA,uDAAuD,8CAA8C;AACrG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,wDAAwD,gCAAgC;AACxF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA,iEAAiE,qCAAqC;AACtG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qEAAqE,yBAAyB;AAC9F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8DAA8D,kCAAkC;AAChG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD,iBAAiB;AACtE;AACA;AACA;AACA;AACA;AACA;AACA,kFAAkF,SAAS;AAC3F;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAiD,iBAAiB;AAClE;AACA;AACA;AACA;AACA;AACA,6EAA6E,SAAS;AACtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wEAAwE,SAAS;AACjF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,WAAW,SAAS;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,kCAAkC;AAClC,oEAAoE,qCAAqC;AACzG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,WAAW,SAAS;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,WAAW,mBAAmB;AAC9B;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,eAAe;AACf;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC,UAAU;AAClD;AACA;AACA,gBAAgB;AAChB;AACA;AACA,aAAa;AACb;AACA,SAAS;AACT;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,kCAAkC;AAClC,iBAAiB,UAAU,4DAA4D,4BAA4B;AACnH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,kCAAkC;AAClC,oEAAoE,mBAAmB;AACvF;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA,qEAAqE,mBAAmB;AACxF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B,iBAAiB;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+CAA+C,iBAAiB;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,uBAAuB;AACnD;AACA;AACA,4DAA4D,6DAA6D;AACzH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,yDAAyD,uBAAuB;AAChF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,2DAA2D,oBAAoB;AAC/E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mDAAmD,QAAQ;AAC3D,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,4BAA4B,yBAAyB;AACrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mDAAmD,QAAQ;AAC3D,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,gCAAgC,yBAAyB;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,+BAA+B;AAC/B;AACA;AACA;AACA,yBAAyB,qFAAqF;AAC9G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,uDAAuD,aAAa;AACpE,sBAAsB,SAAS;AAC/B;AACA,gCAAgC,MAAM;AACtC,UAAU;AACV;AACA,6CAA6C;AAC7C;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,oCAAoC;AACrD;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA;AACA,iDAAiD,aAAa;AAC9D;AACA;AACA;AACA,QAAQ,yBAAyB;AACjC,QAAQ,mBAAmB;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;;AAEA;;AAEA,+DAA+D,aAAa;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,mDAAmD,aAAa;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0DAA0D;AAC1D;AACA,sCAAsC,kDAAkD;AACxF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2EAA2E,+BAA+B;AAC1G;AACA;AACA,iBAAiB,UAAU;AAC3B;AACA,iBAAiB,UAAU;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8EAA8E,SAAS;AACvF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,SAAS;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uDAAuD,yBAAyB;AAChF;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oFAAoF,SAAS;AAC7F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,UAAU;AAC3B;AACA;AACA;AACA,yBAAyB,0CAA0C;AACnE;AACA;AACA,+CAA+C;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,yCAAyC;AAClE;AACA;AACA,+CAA+C;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+EAA+E,SAAS;AACxF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kFAAkF,SAAS;AAC3F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gFAAgF,SAAS;AACzF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gDAAgD,WAAW;AAC3D;AACA;AACA;AACA,iBAAiB;AACjB;AACA,cAAc;AACd;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0CAA0C,WAAW;AACrD;AACA,iBAAiB;AACjB;AACA;AACA;AACA,yCAAyC,iCAAiC;AAC1E;AACA;AACA;AACA,cAAc;AACd;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iFAAiF,SAAS;AAC1F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,gDAAgD,iDAAiD;AACjG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,yBAAyB;AAC/E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,cAAc;AACpD;AACA;AACA;AACA;AACA;AACA,gEAAgE,2BAA2B;AAC3F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,mBAAmB;AACjD;AACA,4CAA4C,+BAA+B;AAC3E;AACA,aAAa;AACb,SAAS;AACT;AACA;AACA;AACA;AACA,kDAAkD,sCAAsC;AACxF;AACA;AACA;AACA;AACA;AACA;AACA,qCAAqC,yBAAyB,8DAA8D,gBAAgB;AAC5I;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb,cAAc,mBAAmB;AACjC;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA,+BAA+B,UAAU;AACzC;AACA;AACA,cAAc;AACd;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB,kBAAkB,mBAAmB;AACrC;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA,0BAA0B;AAC1B;AACA;AACA;AACA,mCAAmC,0BAA0B;AAC7D;AACA;AACA,kBAAkB;AAClB;AACA;AACA,aAAa;AACb,SAAS;AACT;AACA;AACA;AACA,iBAAiB,UAAU,kDAAkD,2BAA2B;AACxG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2DAA2D,kBAAkB;AAC7E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,+DAA+D,wBAAwB;AACvF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD;AACrD;AACA;AACA;AACA;AACA;AACA,oBAAoB,kDAAkD;AACtE;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,kBAAkB;AACtC;AACA;AACA,oBAAoB,uBAAuB;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,iBAAiB;AAC9C;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8DAA8D,2BAA2B;AACzF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA,qEAAqE,eAAe;AACpF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA,iDAAiD,8BAA8B;AAC/E;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA,wCAAwC,8BAA8B;AACtE;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,yDAAyD,wCAAwC;AACjG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,iBAAiB,aAAa;AAC9B,4BAA4B,YAAY;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,iBAAiB,aAAa;AAC9B,gCAAgC,YAAY;AAC5C;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,oCAAoC;AACrD;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA;AACA,iDAAiD,aAAa;AAC9D;AACA;AACA;AACA,QAAQ,qBAAqB;AAC7B,QAAQ,eAAe;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;;AAEA;AACA;AACA;AACA,MAAM,cAAc;AACpB;AACA;AACA;AACA,8CAA8C,aAAa;AAC3D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oEAAoE,yCAAyC;AAC7G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,SAAS;AAClC;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,aAAa;AACb,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2DAA2D,SAAS;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,WAAW,SAAS,iDAAiD,aAAa;AAClG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+DAA+D,SAAS;AACxE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oEAAoE,SAAS;AAC7E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0EAA0E,SAAS;AACnF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,WAAW,QAAQ,gCAAgC;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,sBAAsB;AAC5D;AACA;AACA;AACA;AACA,0BAA0B;AAC1B,gBAAgB,WAAW,QAAQ,gCAAgC;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,SAAS;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA,yDAAyD,YAAY,UAAU,SAAS;AACxF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,qBAAqB,SAAS;AAC9B;AACA;AACA;AACA;AACA,YAAY,iEAAiE;AAC7E;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,SAAS;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mEAAmE,SAAS;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,gBAAgB,WAAW,QAAQ,oBAAoB,mDAAmD,aAAa;AACvH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sEAAsE,SAAS;AAC/E;AACA;AACA;AACA,gBAAgB,WAAW,QAAQ,oBAAoB;AACvD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iEAAiE,SAAS;AAC1E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8DAA8D,SAAS;AACvE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iEAAiE,SAAS;AAC1E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yDAAyD,SAAS;AAClE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gEAAgE,SAAS;AACzE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,SAAS;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR,QAAQ;AACR,QAAQ;AACR,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gEAAgE,SAAS;AACzE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,WAAW,SAAS;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,SAAS;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gEAAgE,SAAS;AACzE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4DAA4D,SAAS;AACrE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8DAA8D,SAAS;AACvE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2DAA2D,SAAS;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA,gBAAgB;AAChB;AACA,gBAAgB;AAChB;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,gBAAgB;AACtE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+DAA+D,KAAK;AACpE;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,4EAA4E;AACpF;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0CAA0C,yBAAyB;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,4EAA4E;AACpF;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mEAAmE,cAAc;AACjF;AACA;AACA;AACA;AACA;AACA,QAAQ,4EAA4E;AACpF;AACA;AACA;AACA;AACA;AACA,sCAAsC;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mEAAmE,cAAc,UAAU,SAAS;AACpG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,MAAM;AACxE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR,8DAA8D,mDAAmD;AACjH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC,sDAAsD;AAC7F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,iBAAiB;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yCAAyC,kBAAkB;AAC3D,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,yDAAyD,WAAW;AACpE,mDAAmD,WAAW;AAC9D,yDAAyD,WAAW;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,qBAAqB;AACzC,2DAA2D,eAAe;AAC1E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0DAA0D,YAAY;AACtE;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B,mEAAmE;AAC7F;AACA;AACA;AACA;AACA,QAAQ;AACR,2DAA2D,YAAY;AACvE;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+DAA+D,WAAW;AAC1E,yDAAyD,WAAW;AACpE,+DAA+D,WAAW;AAC1E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,qBAAqB;AAC7C,+DAA+D,eAAe;AAC9E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,YAAY;AACzE;AACA;AACA;AACA,aAAa;AACb,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,8BAA8B;AAC3C,aAAa;AACb;AACA;AACA;AACA,6BAA6B,oBAAoB;AACjD,mCAAmC,IAAI;AACvC,uCAAuC,QAAQ;AAC/C;AACA,yCAAyC,MAAM;AAC/C;AACA,YAAY;AACZ,QAAQ;AACR;AACA;AACA;AACA,kEAAkE,SAAS,UAAU,SAAS;AAC9F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6EAA6E,SAAS;AACtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC,gBAAgB;AACnD;AACA;AACA;AACA,2EAA2E,SAAS;AACpF;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,iBAAiB;AAC/C;AACA;AACA;AACA;AACA,oDAAoD,KAAK;AACzD,uEAAuE,SAAS;AAChF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2DAA2D,OAAO;AAClE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,qBAAqB,SAAS;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,4FAA4F;AACxG;AACA;AACA;AACA,0BAA0B,2FAA2F;AACrH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,qBAAqB,SAAS;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sEAAsE,MAAM,UAAU,SAAS;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2CAA2C,eAAe;AAC1D;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,OAAO;AACvB,mEAAmE,MAAM,UAAU,SAAS;AAC5F;AACA;AACA;AACA;AACA;AACA,sEAAsE,MAAM,UAAU,SAAS;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,gBAAgB,aAAa;AAC7B;AACA;AACA;AACA,gEAAgE,+BAA+B;AAC/F;AACA;AACA;AACA,iBAAiB;AACjB;AACA,sBAAsB,SAAS;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,oEAAoE,SAAS;AAC7E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,iCAAiC,0BAA0B;AACxE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gFAAgF;AAChF;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,QAAQ;AACR;AACA;AACA,+CAA+C;AAC/C,gBAAgB,0BAA0B;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,iDAAiD;AACzE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC,4BAA4B,GAAG,GAAG;AACzE,uCAAuC,uBAAuB,GAAG,GAAG;AACpE,uCAAuC,4BAA4B,GAAG,GAAG;AACzE,uCAAuC,yBAAyB,GAAG,GAAG;AACtE,uCAAuC,4BAA4B,GAAG,GAAG;AACzE,uCAAuC,yBAAyB,GAAG,GAAG;AACtE;AACA;AACA,2BAA2B,4BAA4B,GAAG,GAAG;AAC7D,2BAA2B,uBAAuB,GAAG,GAAG;AACxD,6BAA6B,4BAA4B,GAAG,GAAG;AAC/D,6BAA6B,yBAAyB,GAAG,GAAG;AAC5D,6BAA6B,4BAA4B,GAAG,GAAG;AAC/D,6BAA6B,yBAAyB,GAAG,GAAG;AAC5D;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B;AAC3B;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,gBAAgB,UAAU,4EAA4E,aAAa;AACnH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA,0BAA0B,YAAY;AACtC,uDAAuD,YAAY;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB,YAAY;AACZ;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA,gBAAgB,UAAU;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA,8EAA8E,SAAS;AACvF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,WAAW,SAAS;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4DAA4D,kCAAkC;AAC9F;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,UAAU;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,UAAU;AAC1B;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA,+CAA+C,aAAa;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8DAA8D,MAAM;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA,+EAA+E,kCAAkC;AACjH;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA,YAAY;AACZ,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mDAAmD,0BAA0B,iDAAiD,OAAO;AACrI;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD,0BAA0B,iDAAiD,OAAO;AACvI;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB;AACvB,WAAW;AACX,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB;AACvB,WAAW;AACX,QAAQ;AACR;AACA;AACA;AACA;AACA,2EAA2E,MAAM;AACjF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C,aAAa;AAC3D;AACA;AACA;AACA;AACA;AACA,IAAI,uCAAuC;AAC3C,iBAAiB,uCAAuC;AACxD,mDAAmD,sCAAsC;AACzF;AACA;AACA,OAAO;AACP,OAAO;AACP,OAAO;AACP;AACA;AACA,OAAO;AACP,OAAO;AACP;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,OAAO;AACP,OAAO;AACP,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA,+EAA+E,iCAAiC;AAChH;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,SAAS,UAAU,SAAS;AACzF,YAAY;AACZ,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qFAAqF,YAAY;AACjG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,0BAA0B;AAC1C;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA,kDAAkD,aAAa;AAC/D;AACA;AACA,0CAA0C,MAAM,EAAE,sCAAsC,iBAAiB,OAAO;AAChH;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8EAA8E,WAAW;AACzF;AACA;AACA;AACA,8BAA8B;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA,aAAa;AACb;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uEAAuE,UAAU,UAAU,UAAU,gBAAgB,YAAY;AACjI;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B;;AAE3B;;AAEA;;AAEA;;AAEA,8CAA8C,aAAa;AAC3D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,uBAAuB;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yCAAyC,cAAc;AACvD;AACA,kDAAkD,iBAAiB;AACnE,aAAa;AACb,4DAA4D,4BAA4B;AACxF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,OAAO;AACzB;AACA;AACA;AACA,oBAAoB,qCAAqC;AACzD,oBAAoB,kBAAkB;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,kBAAkB,OAAO;AACzB;AACA;AACA;AACA,oBAAoB,6BAA6B;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wEAAwE,mBAAmB;AAC3F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uDAAuD,YAAY;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4DAA4D,mBAAmB;AAC/E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB;;AAEvB;;AAEA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iFAAiF,uBAAuB;AACxG;AACA;AACA;AACA;AACA;AACA,+EAA+E,uBAAuB;AACtG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,gBAAgB;AAC7C;AACA;AACA,+BAA+B,gBAAgB;AAC/C;AACA;AACA,0BAA0B,KAAK;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,kCAAkC;AAC/F;AACA,SAAS;AACT;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+DAA+D,kCAAkC;AACjG;AACA,SAAS;AACT;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA,yDAAyD,aAAa;AACtE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA,iGAAiG,oCAAoC;AACrI,wBAAwB,yCAAyC,oBAAoB;AACrF,8EAA8E,wCAAwC;AACtH;AACA;AACA,OAAO;AACP,OAAO;AACP,OAAO;AACP,OAAO;AACP,OAAO;AACP;AACA;AACA,OAAO;AACP,OAAO;AACP,OAAO;AACP;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,OAAO;AACP,OAAO;AACP,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iFAAiF,SAAS,UAAU,SAAS,gBAAgB,YAAY;AACzI;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4EAA4E,mCAAmC;AAC/G,YAAY;AACZ,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2DAA2D,SAAS,UAAU,SAAS;AACvF,YAAY;AACZ,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,oDAAoD;AACxE,qBAAqB;AACrB,SAAS;AACT;AACA;AACA;AACA;AACA,sCAAsC,QAAQ,oBAAoB,UAAU,oBAAoB,gBAAgB,2BAA2B;AAC3I;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,qBAAqB,QAAQ,oBAAoB,UAAU,oBAAoB,gBAAgB,2BAA2B;AAC1H;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,aAAa;AACjC;AACA;AACA;AACA;AACA,8EAA8E,QAAQ,KAAK,UAAU,MAAM;AAC3G,yFAAyF,OAAO;AAChG,kBAAkB,QAAQ,aAAa,UAAU,cAAc;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mDAAmD,aAAa;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,uDAAuD,aAAa;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,yFAAyF;AACzG;AACA;AACA,8EAA8E;AAC9E;AACA;AACA;AACA,kFAAkF,mBAAmB,UAAU,mBAAmB,gBAAgB,KAAK;AACvJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,uDAAuD,aAAa;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2FAA2F,2CAA2C;AACtI;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2FAA2F,2CAA2C;AACtI;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C;AAC7C;AACA;AACA,yDAAyD,aAAa;AACtE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yGAAyG;AACzG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,8DAA8D;AAC1F,kCAAkC;AAClC;AACA;AACA;AACA,mCAAmC;AACnC;AACA;AACA;AACA,6BAA6B;AAC7B;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC,6BAA6B;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kCAAkC;AAClC;AACA;AACA;AACA;AACA,gBAAgB,6EAA6E;AAC7F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD,6BAA6B;AAClF;AACA;AACA,gBAAgB,yCAAyC;AACzD;AACA;AACA;AACA;AACA;AACA,uCAAuC,6BAA6B;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0DAA0D,kCAAkC;AAC5F;AACA;AACA;AACA;AACA,4BAA4B,yCAAyC;AACrE;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA,qDAAqD,0DAA0D;AAC/G;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,MAAM,eAAe;AACrB,MAAM,6BAA6B;AACnC,MAAM,+BAA+B;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAiD,aAAa;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B;AAC1B,sBAAsB;AACtB,oBAAoB;AACpB,uBAAuB;AACvB;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,KAAK;AACL;AACA;AACA,2EAA2E,sCAAsC;AACjH,iCAAiC,kCAAkC;AACnE;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,OAAO;AACP,OAAO;AACP,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA,iBAAiB;AACjB;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gEAAgE,SAAS;AACzE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yEAAyE;AACzE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yEAAyE;AACzE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B;AAC5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,sFAAsF,8BAA8B;AACpH;AACA,0EAA0E,YAAY;AACtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sEAAsE,YAAY;AAClF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU,oBAAoB;AAC9B;AACA,6DAA6D,YAAY;AACzE;AACA;AACA;AACA;AACA,4BAA4B,qBAAqB;AACjD;AACA;AACA;AACA,qEAAqE,kCAAkC;AACvG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2CAA2C;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB;AACvB,gBAAgB,wBAAwB;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6FAA6F,kBAAkB,UAAU,kBAAkB,gBAAgB,uBAAuB;AAClL;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,4BAA4B,qBAAqB;AACjD;AACA;AACA;AACA,qEAAqE,sCAAsC;AAC3G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,WAAW,2BAA2B,iDAAiD,aAAa;AACpH;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;;AAEA,mDAAmD,aAAa;AAChE;AACA;AACA;AACA;AACA,MAAM,2BAA2B;AACjC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2CAA2C,WAAW;AACtD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gFAAgF,UAAU;AAC1F,gCAAgC,UAAU;AAC1C,0BAA0B,iBAAiB;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAiD,UAAU;AAC3D;AACA;AACA;AACA,mDAAmD,UAAU;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,WAAW,iEAAiE;AAC5F;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B;AACA;AACA,SAAS;AACT;AACA;AACA,gBAAgB,WAAW,kCAAkC;AAC7D,0BAA0B;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,SAAS;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,KAAK;AACnC,KAAK;AACL;AACA;;AAEA;;AAEA;AACA;AACA;AACA,MAAM,iBAAiB;AACvB;AACA;AACA;AACA,iDAAiD,aAAa;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,UAAU,sDAAsD,MAAM;AACtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB;AACvB;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC,mBAAmB;AACvD,gBAAgB,UAAU;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,UAAU,sDAAsD,MAAM;AACtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,UAAU,qDAAqD,MAAM;AACrF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD,gCAAgC;AACrF;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,UAAU,yDAAyD,MAAM;AACzF;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA,+BAA+B,oEAAoE;AACnG,4CAA4C,0EAA0E;AACtH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4FAA4F,SAAS;AACrG;AACA;AACA;;AAEA,iDAAiD,aAAa;AAC9D;AACA;AACA;AACA;AACA,oEAAoE,2BAA2B;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,iFAAiF,MAAM;AACvF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,iEAAiE,MAAM;AACvE;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,gBAAgB,oCAAoC;AACpD;AACA;AACA,EAAE;AACF;AACA;AACA,EAAE;AACF;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA,OAAO,iCAAiC;AACxC,OAAO,2BAA2B;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAE;;AAEF;;AAEA;;AAEA;;AAEA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,uDAAuD;AACpH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iEAAiE,gDAAgD;AACjH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6EAA6E,SAAS;AACtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gFAAgF,SAAS;AACzF;AACA;AACA;;AAEA,iDAAiD,aAAa;AAC9D;AACA;AACA;AACA;AACA;AACA,oEAAoE,cAAc;AAClF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,sCAAsC;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC,sCAAsC;AAC9E;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,OAAO,oBAAoB;AAC3B,OAAO,cAAc;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,oCAAoC;AACpD;AACA;AACA,EAAE;AACF;AACA;AACA,EAAE;AACF;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA,EAAE;;AAEF;;AAEA,oDAAoD,aAAa;AACjE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,QAAQ;AAC9B,QAAQ;AACR;AACA;AACA,QAAQ;AACR;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA,+DAA+D,QAAQ;AACvE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA,iEAAiE,QAAQ;AACzE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qEAAqE;AACrE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAiC,QAAQ,kBAAkB,WAAW;AACtE,QAAQ;AACR;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA,gBAAgB,WAAW,SAAS,8DAA8D,QAAQ;AAC1G;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,6CAA6C;AACtE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,oBAAoB,OAAO;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oDAAoD,KAAK;AACzD,0EAA0E,aAAa;AACvF;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC,+CAA+C;AACvF;AACA;AACA,gCAAgC;AAChC,yBAAyB;AACzB;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,mIAAmI,yBAAyB;AAC5J;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B;AAC5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+EAA+E;AAC/E;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,qIAAqI,yBAAyB;AAC9J;AACA,gBAAgB,WAAW;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,mCAAmC,8CAA8C;AACjF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC,8BAA8B;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,2BAA2B;AAC7F;AACA;AACA;AACA;AACA;AACA,4CAA4C,+CAA+C;AAC3F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,cAAc;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2DAA2D,uCAAuC;AAClG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4CAA4C,4BAA4B;AACxE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iEAAiE,4BAA4B;AAC7F;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA,mCAAmC,OAAO,IAAI,IAAI;AAClD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,iCAAiC,iDAAiD;AAClF;AACA;AACA,0CAA0C,kCAAkC;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4DAA4D,aAAa;AACzE;AACA;AACA;AACA;AACA;AACA;AACA,2FAA2F,+CAA+C;AAC1I;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,kDAAkD,uBAAuB;AACzE;AACA;AACA;AACA;AACA,kCAAkC,iDAAiD;AACnF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC,SAAS;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC,SAAS;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC;AACvC;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,gBAAgB,aAAa;AAC7B;AACA;AACA;AACA,gCAAgC;AAChC,SAAS;AACT;AACA;AACA,+EAA+E,iDAAiD;AAChI;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B;AAC/B;AACA;AACA;AACA,+BAA+B,KAAK;AACpC;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC;AACtC;AACA;AACA,yCAAyC;AACzC;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,gBAAgB,aAAa;AAC7B;AACA,gCAAgC,gDAAgD;AAChF;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uFAAuF,oCAAoC;AAC3H;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+CAA+C,wBAAwB;AACvE;AACA;AACA;AACA,4CAA4C,yBAAyB;AACrE;AACA;AACA,SAAS;AACT;AACA,iDAAiD,mBAAmB;AACpE;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA,mDAAmD,aAAa;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB;;AAExB;AACA;AACA;AACA;AACA;AACA;AACA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0EAA0E,2CAA2C;AACrH;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,cAAc;AAC9B;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,IAAI;AACJ;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uUAAuU,yCAAyC;AAChX;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B,4BAA4B;AAC3D,8BAA8B;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B;AAC5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA,wBAAwB;AACxB,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,kCAAkC;AAClC;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA,wBAAwB;AACxB,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,aAAa;AACb;AACA;AACA;AACA;AACA,sCAAsC,oBAAoB;AAC1D;AACA;AACA;AACA,sCAAsC,oBAAoB;AAC1D;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,oBAAoB,aAAa;AACjC;AACA;AACA;AACA;AACA;AACA,wBAAwB;AACxB,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD,qBAAqB;AAC1E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wDAAwD,gBAAgB;AACxE;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAiD,aAAa;AAC9D;AACA;AACA;AACA;AACA;AACA,oEAAoE,cAAc;AAClF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,cAAc;AACrC;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB,YAAY;AACZ;AACA;AACA;AACA,2DAA2D,aAAa;AACxE;AACA;AACA,uCAAuC;AACvC;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAiC;AACjC;AACA;AACA;AACA,yCAAyC;AACzC;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C;AAC7C;AACA,iEAAiE,eAAe;AAChF;AACA;AACA,aAAa;AACb,0EAA0E,6BAA6B;AACvG;AACA;AACA;AACA,iEAAiE,eAAe;AAChF;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,gBAAgB,aAAa;AAC7B,2BAA2B,YAAY;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,gBAAgB,aAAa;AAC7B,+BAA+B,YAAY;AAC3C;AACA;AACA;AACA;AACA;AACA,mEAAmE,OAAO;AAC1E;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,OAAO,oBAAoB;AAC3B,OAAO,cAAc;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,oCAAoC;AACpD;AACA;AACA,EAAE;AACF;AACA;AACA,EAAE;AACF;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA,EAAE;;AAEF,iDAAiD,aAAa;AAC9D;AACA;AACA;AACA;AACA;AACA,oEAAoE,gBAAgB;AACpF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,cAAc;AACjC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B;AAC5B;AACA,qCAAqC,cAAc;AACnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B,iBAAiB;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,WAAW;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,2CAA2C,qBAAqB;AAChE;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,WAAW;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,2CAA2C,qBAAqB;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,2BAA2B,yBAAyB;AACpD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,+BAA+B,yBAAyB;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,wBAAwB,OAAO;AAC/B;AACA,iEAAiE,gDAAgD;AACjH;AACA;AACA,6EAA6E,MAAM;AACnF;AACA,2BAA2B,MAAM;AACjC;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6EAA6E,yBAAyB;AACtG;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,gBAAgB,oCAAoC;AACpD;AACA;AACA,EAAE;AACF;AACA;AACA,EAAE;AACF;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA,OAAO,sBAAsB;AAC7B,OAAO,gBAAgB;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAE;;AAEF;;AAEA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA,aAAa,yBAAyB;AACtC;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA,0DAA0D,YAAY;AACtE;AACA;AACA,cAAc;AACd;AACA,+DAA+D,YAAY;AAC3E;AACA;AACA,cAAc;AACd;AACA,6DAA6D,YAAY;AACzE;AACA;AACA,cAAc;AACd;AACA,yFAAyF,MAAM;AAC/F;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAE;;AAEF;;AAEA;;AAEA;;AAEA,0DAA0D,aAAa;AACvE;AACA;AACA;AACA;AACA;AACA,uBAAuB;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA,kEAAkE,aAAa;AAC/E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,QAAQ;AAC1E,kEAAkE,QAAQ;AAC1E,oEAAoE,QAAQ;AAC5E,sEAAsE,QAAQ;AAC9E;AACA;AACA;AACA;AACA;AACA,iBAAiB,UAAU;AAC3B;AACA;AACA,6EAA6E,mCAAmC,aAAa,wBAAwB;AACrJ;AACA;AACA;AACA;AACA,sDAAsD,qBAAqB,EAAE,qBAAqB;AAClG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA,iBAAiB,yBAAyB;AAC1C;AACA;AACA,sDAAsD,qBAAqB,EAAE,qBAAqB;AAClG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA,iBAAiB,YAAY;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA,oGAAoG,UAAU,oBAAoB,eAAe;AACjJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,gDAAgD,aAAa;AAC7D;AACA,6BAA6B,cAAc,EAAE,WAAW;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,WAAW,mBAAmB,aAAa,IAAI,MAAM;AAC3G;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC,WAAW,MAAM,WAAW;AACpE;AACA;AACA;AACA,aAAa,aAAa;AAC1B;AACA,oCAAoC,KAAK,GAAG,MAAM,aAAa,kBAAkB,KAAK,eAAe,MAAM,WAAW;AACtH,oCAAoC,KAAK,GAAG,MAAM,aAAa,eAAe,MAAM,WAAW;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,UAAU,IAAI,MAAM;AAC1E;AACA;AACA;AACA;AACA;AACA,EAAE;;AAEF;;AAEA;;AAEA;AACA;AACA;AACA,+DAA+D,aAAa;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,aAAa;AAClC;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,iBAAiB,UAAU;AAC3B;AACA;AACA,sDAAsD,gCAAgC,EAAE,+BAA+B;AACvH;AACA;AACA;AACA,2EAA2E,mCAAmC,aAAa,wBAAwB;AACnJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,iBAAiB,cAAc;AAC/B;AACA;AACA,sDAAsD,2BAA2B,EAAE,0BAA0B;AAC7G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,yBAAyB;AAC1C;AACA;AACA,sDAAsD,2BAA2B,EAAE,0BAA0B;AAC7G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,iBAAiB,YAAY;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,kCAAkC,YAAY,2BAA2B;AAClG;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA,uGAAuG,OAAO,mBAAmB,UAAU,UAAU,4BAA4B,UAAU,4BAA4B,gBAAgB,kCAAkC;AACzQ;AACA;AACA;AACA;AACA,oGAAoG,UAAU,UAAU,4BAA4B,UAAU,4BAA4B,gBAAgB,kCAAkC;AAC5O;AACA;AACA;AACA,iBAAiB,YAAY;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oGAAoG,UAAU,oBAAoB,GAAG;AACrI;AACA;AACA;AACA;AACA,iBAAiB,YAAY;AAC7B;AACA,sDAAsD,2BAA2B,EAAE,0BAA0B;AAC7G;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;AACA,UAAU;AACV;AACA;AACA;AACA,iBAAiB,YAAY;AAC7B;AACA,sDAAsD,SAAS,EAAE,QAAQ;AACzE;AACA;AACA;AACA;AACA;AACA,iBAAiB,YAAY;AAC7B;AACA,sDAAsD,SAAS,EAAE,QAAQ;AACzE;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,kCAAkC,EAAE,iCAAiC;AAC3H;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,aAAa;AAC9B;AACA;AACA;AACA;AACA;AACA,qBAAqB,kBAAkB,mCAAmC,0BAA0B;AACpG;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,kGAAkG,OAAO,8BAA8B,iCAAiC,UAAU,iCAAiC,gBAAgB,uCAAuC;AAC1Q;AACA;AACA;AACA;AACA,iBAAiB,aAAa;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA,yDAAyD,WAAW;AACpE,kBAAkB;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wDAAwD,4BAA4B;AACpF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,aAAa;AAClC;AACA;AACA,cAAc;AACd,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C;AAC9C;AACA;AACA,sDAAsD,aAAa;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,2FAA2F,iGAAiG;AAC5L,wBAAwB,oCAAoC;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,2HAA2H;AACjJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,mBAAmB;AACzD;AACA,kEAAkE,mBAAmB;AACrF;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,SAAS;AAC3B;AACA;AACA,UAAU;AACV;AACA;AACA,qBAAqB,iBAAiB;AACtC,uCAAuC,SAAS;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,qBAAqB,EAAE,qBAAqB;AAClG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B,SAAS;AACnC;AACA;AACA,UAAU;AACV;AACA;AACA,iHAAiH,eAAe;AAChI;AACA;AACA;AACA,6EAA6E,mCAAmC,aAAa,wBAAwB;AACrJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,iBAAiB,iBAAiB;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qGAAqG,mFAAmF;AACxL;AACA;AACA;AACA;AACA;AACA,8BAA8B,wBAAwB;AACtD;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,gBAAgB;AACtE;AACA;AACA;AACA;AACA;AACA,uDAAuD,aAAa,EAAE,aAAa;AACnF;AACA;AACA;AACA,iFAAiF,aAAa,EAAE,YAAY;AAC5G;AACA;AACA;AACA,kEAAkE,gBAAgB;AAClF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kDAAkD,gBAAgB;AAClE;AACA;AACA;AACA;AACA,6BAA6B,oEAAoE;AACjG;AACA;AACA;AACA;AACA;AACA,qCAAqC,gBAAgB;AACrD;AACA;AACA,UAAU;AACV;AACA;AACA,sDAAsD,qBAAqB,EAAE,qBAAqB;AAClG;AACA;AACA,wFAAwF,eAAe;AACvG;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,yBAAyB;AAClD;AACA;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,6FAA6F;AACxH;AACA;AACA;AACA;AACA;AACA,oCAAoC,QAAQ;AAC5C;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+EAA+E,aAAa,EAAE,YAAY;AAC1G;AACA;AACA,iFAAiF,aAAa,EAAE,YAAY;AAC5G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,gFAAgF;AAC7G;AACA;AACA,oBAAoB,iBAAiB;AACrC;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,sBAAsB;AACtB,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,gBAAgB;AAC9C;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC,gBAAgB;AACnD;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wDAAwD,4CAA4C;AACpG;AACA,0DAA0D,oCAAoC;AAC9F,wEAAwE,+CAA+C;AACvH;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,sEAAsE;AACnG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,6CAA6C,YAAY;AACzD;AACA;AACA;AACA;AACA,oDAAoD,0CAA0C;AAC9F;AACA;AACA;AACA;AACA;AACA,6CAA6C,0CAA0C;AACvF;AACA;AACA;AACA;AACA,6BAA6B,iCAAiC;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA,mFAAmF,oBAAoB,GAAG,oBAAoB,GAAG,0BAA0B;AAC3J;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,wCAAwC;AACjE,wBAAwB,eAAe,IAAI,kBAAkB,IAAI,eAAe;AAChF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,wCAAwC;AACjE,wBAAwB,eAAe;AACvC,YAAY;AACZ;AACA,yBAAyB,wCAAwC;AACjE,wBAAwB,eAAe,IAAI,kBAAkB,IAAI,eAAe;AAChF,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,wCAAwC;AACjE,wBAAwB,eAAe,IAAI,kBAAkB,IAAI,eAAe;AAChF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC,aAAa;AAC7C,4DAA4D,KAAK,GAAG,MAAM;AAC1E;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,cAAc;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,WAAW,mBAAmB,cAAc,YAAY,oBAAoB,GAAG,oBAAoB,GAAG,0BAA0B;AAC7L;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC,UAAU;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2EAA2E,iGAAiG;AAC5K;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,cAAc;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wDAAwD,4CAA4C;AACpG;AACA,0DAA0D,oCAAoC;AAC9F,wEAAwE,+CAA+C;AACvH;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,uCAAuC;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,kDAAkD;AACvE;AACA;AACA;AACA;AACA,iCAAiC,yBAAyB;AAC1D;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wJAAwJ,eAAe;AACvK;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC,wBAAwB;AACxD,+BAA+B;AAC/B;AACA;AACA;AACA,qBAAqB,iBAAiB;AACtC;AACA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,YAAY;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA,oDAAoD,mDAAmD;AACvG;AACA;AACA;AACA,+CAA+C,mDAAmD;AAClG;AACA;AACA,qBAAqB,iBAAiB;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iEAAiE,WAAW,aAAa,oBAAoB,GAAG,oBAAoB,GAAG,0BAA0B;AACjK;AACA;AACA;AACA;AACA,4BAA4B,WAAW;AACvC;AACA;AACA;AACA;AACA;AACA,qCAAqC,uBAAuB;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA,sBAAsB;AACtB;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,KAAK;AAC1B;AACA;AACA;AACA,0BAA0B;AAC1B;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA,0BAA0B;AAC1B;AACA;AACA;AACA,sBAAsB;AACtB;AACA,kBAAkB;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kFAAkF,MAAM;AACxF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,oBAAoB,IAAI,oBAAoB;AAC9G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;AACA,cAAc;AACd;AACA,UAAU;AACV;AACA;AACA,4CAA4C,OAAO,uBAAuB,oBAAoB,IAAI,oBAAoB;AACtH;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,qBAAqB,YAAY;AACjC;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mEAAmE,aAAa;AAChF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,iEAAiE,QAAQ;AACzE;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,iEAAiE,QAAQ;AACzE;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,wDAAwD,QAAQ,GAAG,YAAY,GAAG,4BAA4B;AAC9G;AACA;AACA,wDAAwD,QAAQ;AAChE;AACA;AACA,kEAAkE,QAAQ,KAAK,wBAAwB;AACvG,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA,wEAAwE,QAAQ,KAAK,WAAW;AAChG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,eAAe,oCAAoC;AACnD;AACA;AACA,CAAC;AACD;AACA;AACA,CAAC;AACD;AACA,0CAA0C,4BAA4B;AACtE,CAAC;AACD;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8DAA8D,aAAa;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mDAAmD,SAAS;AAC5D;AACA;AACA,2DAA2D,aAAa;AACxE;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAiD,QAAQ,GAAG,YAAY,GAAG,qBAAqB;AAChG;AACA;AACA,iDAAiD,QAAQ,GAAG,qBAAqB;AACjF;AACA;AACA,2BAA2B;AAC3B;AACA,4DAA4D,wBAAwB;AACpF;AACA;AACA;AACA;AACA;AACA;AACA,sEAAsE,WAAW;AACjF;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,WAAW;AAC7E;AACA;AACA;AACA,0DAA0D,QAAQ,GAAG,qBAAqB;AAC1F;AACA,2BAA2B;AAC3B;AACA,2DAA2D,WAAW;AACtE;AACA;AACA;AACA,iDAAiD,QAAQ,GAAG,qBAAqB;AACjF;AACA,2BAA2B;AAC3B;AACA,2DAA2D,WAAW;AACtE;AACA;AACA;AACA,kDAAkD,QAAQ,GAAG,qBAAqB;AAClF;AACA,2BAA2B;AAC3B;AACA,4DAA4D,WAAW;AACvE;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,8CAA8C;AAC9C;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC,SAAS,sBAAsB,aAAa,8BAA8B,YAAY,wDAAwD,aAAa;AAC9L;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAE,gEAAgE;AAClE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAE,oDAAoD;AACtD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD,WAAW;AAChE;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,WAAW;AAC5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C;AAC7C;AACA;AACA,6CAA6C,WAAW;AACxD;AACA,UAAU;AACV,MAAM;AACN;AACA,8BAA8B,8CAA8C,IAAI;AAChF,kCAAkC,kCAAkC,IAAI;AACxE;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,QAAQ;AACzB;AACA;AACA;AACA;AACA,qBAAqB,WAAW;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA,EAAE;;AAEF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C;AAC9C;AACA;AACA,mDAAmD,aAAa;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,iGAAiG,cAAc;AAC/G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB;AACtB,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,yBAAyB,aAAa;AACtC;AACA,cAAc;AACd,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,mCAAmC;AACzE,SAAS,kFAAkF;AAC3F;AACA,kCAAkC,qBAAqB,IAAI,gBAAgB;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,0BAA0B;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,qBAAqB,oCAAoC;AACzD,qBAAqB,WAAW;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uIAAuI,sEAAsE;AAC7M;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,iBAAiB,mCAAmC;AACpD,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,yDAAyD,uBAAuB;AAChF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,6DAA6D,wBAAwB,eAAe;AACpG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,kCAAkC,kBAAkB;AACpD;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,mCAAmC;AACzE,SAAS,oFAAoF;AAC7F;AACA,kCAAkC,qBAAqB,IAAI,gBAAgB;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,0BAA0B;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+GAA+G,eAAe,qBAAqB;AACnJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,yBAAyB,2BAA2B;AACpD,mDAAmD,SAAS;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,yDAAyD,mCAAmC,cAAc;AAC1G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,wCAAwC,qBAAqB,eAAe;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,mHAAmH,eAAe,qBAAqB;AACvJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,mHAAmH,eAAe,qBAAqB;AACvJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,oCAAoC;AACzD,qBAAqB,qCAAqC;AAC1D;AACA;AACA,iDAAiD,oBAAoB,IAAI;AACzE;AACA;AACA;AACA;AACA;AACA,wCAAwC;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4EAA4E,oBAAoB;AAChG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0GAA0G,WAAW;AACrH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB;AACtB,UAAU;AACV;AACA;AACA;AACA;AACA,gCAAgC,iDAAiD;AACjF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC,iDAAiD;AACjF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4FAA4F,oBAAoB;AAChH;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C;AAC9C;AACA;AACA,sDAAsD,aAAa;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+CAA+C;AAC/C,sGAAsG;AACtG;AACA;AACA;AACA;AACA,iBAAiB,8CAA8C;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR,QAAQ;AACR,QAAQ;AACR,QAAQ;AACR;AACA;AACA;AACA,QAAQ;AACR,QAAQ;AACR,QAAQ;AACR,QAAQ;AACR,QAAQ;AACR;AACA;AACA,QAAQ;AACR,QAAQ;AACR,QAAQ;AACR,QAAQ;AACR,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC,yBAAyB,QAAQ;AACxE;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,gDAAgD,SAAS;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,WAAW;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,WAAW;AAC/B;AACA;AACA;AACA;AACA,oBAAoB,WAAW;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,WAAW;AAC/B;AACA;AACA;AACA;AACA,oBAAoB,WAAW;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA,iDAAiD,YAAY,GAAG,0BAA0B;AAC1F;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,wBAAwB;AACrF;AACA;AACA;AACA,iEAAiE,WAAW;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,sDAAsD,wBAAwB;AAC9E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,4DAA4D,QAAQ;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,iEAAiE,gBAAgB;AACjF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,4DAA4D,gBAAgB;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B,+BAA+B;AACzD;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,UAAU;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,6CAA6C,WAAW;AACxD;AACA;AACA;AACA,gEAAgE,uBAAuB;AACvF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0CAA0C,0BAA0B,gBAAgB;AACpF;AACA;AACA;AACA;AACA,0CAA0C,uBAAuB,kBAAkB;AACnF,0CAA0C,0BAA0B,gBAAgB;AACpF;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,uDAAuD,aAAa;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,+CAA+C;AACrG,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA,0CAA0C,WAAW;AACrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,cAAc;AACnC;AACA,cAAc;AACd;AACA,8EAA8E,sBAAsB;AACpG;AACA;AACA;AACA;AACA;AACA;AACA,2FAA2F,sBAAsB,KAAK,MAAM;AAC5H;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,yBAAyB;AAC7C,4DAA4D,YAAY;AACxE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,qBAAqB,OAAO;AAC5B,wBAAwB,iEAAiE;AACzF,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mEAAmE,QAAQ;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA,sDAAsD,aAAa;AACnE;AACA;AACA,iDAAiD,0BAA0B;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA,kPAAkP,yBAAyB;AAC3Q;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,8CAA8C;AAC9C;AACA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oGAAoG,yBAAyB;AAC7H;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA,kFAAkF,KAAK;AACvF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,mFAAmF,KAAK;AACxF;AACA,cAAc;AACd,UAAU;AACV;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,qBAAqB;AAC7B,QAAQ,qBAAqB,KAAK,qBAAqB;AACvD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,oCAAoC;AACrD;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA;AACA,iDAAiD,aAAa;AAC9D;AACA;AACA;AACA,GAAG;AACH;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA,6CAA6C,aAAa;AAC1D;AACA;AACA,gDAAgD,cAAc,EAAE,QAAQ;AACxE;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wDAAwD,uCAAuC;AAC/F;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,iGAAiG,aAAa;AAC9G;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC,kDAAkD;AACrF;AACA;AACA;AACA;AACA;AACA;AACA,iCAAiC,cAAc;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gEAAgE,oDAAoD;AACpH;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,kEAAkE,oDAAoD;AACtH;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,mDAAmD,UAAU;AAC7D;AACA;AACA;AACA;;AAEA,+CAA+C,aAAa;AAC5D;AACA;AACA;AACA;AACA;AACA,oEAAoE,sBAAsB;AAC1F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB,SAAS;AACT,8CAA8C,UAAU;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,OAAO,4BAA4B;AACnC,OAAO,sBAAsB;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,oCAAoC;AACpD;AACA;AACA,EAAE;AACF;AACA;AACA,EAAE;AACF;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA,EAAE;;AAEF,6CAA6C,aAAa;AAC1D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;;AAEA;;AAEA;;AAEA,4CAA4C,aAAa;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mEAAmE,wBAAwB;AAC3F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,uDAAuD,aAAa;AACpE;AACA;AACA;AACA;AACA;AACA,YAAY,QAAQ;AACpB;AACA,gBAAgB,aAAa;AAC7B;AACA;AACA;AACA,gBAAgB,OAAO;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,UAAU;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C;AAC7C;AACA;AACA,iDAAiD,aAAa;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,YAAY;AACxC,6BAA6B,wCAAwC;AACrE;AACA;AACA;AACA,SAAS;AACT,gBAAgB,aAAa;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC,sCAAsC,KAAK,GAAG;AACtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,gBAAgB;AAChC,iCAAiC;AACjC;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,qCAAqC,mBAAmB;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA,yCAAyC,qBAAqB;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,sBAAsB;AAC1C;AACA,6BAA6B,wHAAwH;AACrJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAiC,kCAAkC;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,uDAAuD,aAAa;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kCAAkC,cAAc;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,KAAK;;AAEL,eAAe;AACf,kBAAe;AACf,WAAW;;;;;;;;;;;;AC7niBX;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEa;;AAEb;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,EAAE;AACF;AACA;AACA;AACA;AACA,EAAE;AACF;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,mBAAmB;;AAEnB;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,kBAAkB,sBAAsB;AACxC;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA,eAAe;AACf;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA,IAAI;AACJ;AACA;AACA,oBAAoB,SAAS;AAC7B;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA,MAAM;AACN;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;;AAEA,kCAAkC,QAAQ;AAC1C;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,oBAAoB,iBAAiB;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA,QAAQ;AACR;AACA,uCAAuC,QAAQ;AAC/C;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,MAAM;AACN;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,kBAAkB,OAAO;AACzB;AACA;AACA;;AAEA;AACA,SAAS,yBAAyB;AAClC;AACA;AACA;;AAEA;AACA;AACA,kBAAkB,gBAAgB;AAClC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA,8DAA8D,YAAY;AAC1E;AACA,8DAA8D,YAAY;AAC1E;AACA,GAAG;AACH;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA,qCAAqC,YAAY;AACjD;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,IAAI;AACJ;AACA;AACA;;;;;;;;;;;AChfA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,WAAW,mBAAO,CAAC,mDAAS;;AAE5B;AACA;;AAEA;;;;;;;;;;;ACNA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,cAAc,mBAAO,CAAC,yDAAY;AAClC,cAAc,mBAAO,CAAC,yDAAY;AAClC,cAAc,mBAAO,CAAC,yDAAY;;AAElC;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC/BA,qBAAqB,mBAAO,CAAC,uEAAmB;AAChD,sBAAsB,mBAAO,CAAC,yEAAoB;AAClD,mBAAmB,mBAAO,CAAC,mEAAiB;AAC5C,mBAAmB,mBAAO,CAAC,mEAAiB;AAC5C,mBAAmB,mBAAO,CAAC,mEAAiB;;AAE5C;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC/BA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,WAAW,mBAAO,CAAC,mDAAS;;AAE5B;AACA;;AAEA;;;;;;;;;;;ACNA,oBAAoB,mBAAO,CAAC,qEAAkB;AAC9C,qBAAqB,mBAAO,CAAC,uEAAmB;AAChD,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,kBAAkB,mBAAO,CAAC,iEAAgB;;AAE1C;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC/BA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,WAAW,mBAAO,CAAC,mDAAS;;AAE5B;AACA;;AAEA;;;;;;;;;;;ACNA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,WAAW,mBAAO,CAAC,mDAAS;;AAE5B;AACA;;AAEA;;;;;;;;;;;ACNA,eAAe,mBAAO,CAAC,2DAAa;AACpC,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,kBAAkB,mBAAO,CAAC,iEAAgB;;AAE1C;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;;;;;;;;;;AC1BA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,eAAe,mBAAO,CAAC,2DAAa;AACpC,eAAe,mBAAO,CAAC,2DAAa;AACpC,eAAe,mBAAO,CAAC,2DAAa;;AAEpC;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC1BA,WAAW,mBAAO,CAAC,mDAAS;;AAE5B;AACA;;AAEA;;;;;;;;;;;ACLA,WAAW,mBAAO,CAAC,mDAAS;;AAE5B;AACA;;AAEA;;;;;;;;;;;ACLA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,WAAW,mBAAO,CAAC,mDAAS;;AAE5B;AACA;;AAEA;;;;;;;;;;;ACNA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,UAAU;AACrB,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACrBA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,UAAU;AACrB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACxBA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,kBAAkB,mBAAO,CAAC,+DAAe;AACzC,cAAc,mBAAO,CAAC,uDAAW;AACjC,eAAe,mBAAO,CAAC,yDAAY;AACnC,cAAc,mBAAO,CAAC,yDAAY;AAClC,mBAAmB,mBAAO,CAAC,iEAAgB;;AAE3C;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,WAAW,SAAS;AACpB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AChDA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACnBA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,UAAU;AACrB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACtBA,sBAAsB,mBAAO,CAAC,yEAAoB;AAClD,SAAS,mBAAO,CAAC,6CAAM;;AAEvB;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,GAAG;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC3BA,SAAS,mBAAO,CAAC,6CAAM;;AAEvB;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,GAAG;AACd,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACpBA,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,WAAW,mBAAO,CAAC,iDAAQ;;AAE3B;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AChBA,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,aAAa,mBAAO,CAAC,qDAAU;;AAE/B;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AChBA,qBAAqB,mBAAO,CAAC,uEAAmB;;AAEhD;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,GAAG;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,IAAI;AACJ;AACA;AACA;;AAEA;;;;;;;;;;;ACxBA,YAAY,mBAAO,CAAC,qDAAU;AAC9B,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,mBAAmB,mBAAO,CAAC,mEAAiB;AAC5C,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,oBAAoB,mBAAO,CAAC,qEAAkB;AAC9C,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,mBAAmB,mBAAO,CAAC,mEAAiB;AAC5C,aAAa,mBAAO,CAAC,uDAAW;AAChC,qBAAqB,mBAAO,CAAC,uEAAmB;AAChD,qBAAqB,mBAAO,CAAC,uEAAmB;AAChD,sBAAsB,mBAAO,CAAC,yEAAoB;AAClD,cAAc,mBAAO,CAAC,uDAAW;AACjC,eAAe,mBAAO,CAAC,yDAAY;AACnC,YAAY,mBAAO,CAAC,mDAAS;AAC7B,eAAe,mBAAO,CAAC,yDAAY;AACnC,YAAY,mBAAO,CAAC,mDAAS;AAC7B,WAAW,mBAAO,CAAC,iDAAQ;AAC3B,aAAa,mBAAO,CAAC,qDAAU;;AAE/B;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,WAAW,SAAS;AACpB;AACA;AACA;AACA,WAAW,UAAU;AACrB,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,aAAa,GAAG;AAChB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;;AAEA;AACA;AACA;AACA;AACA,uCAAuC;AACvC;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;AACL,IAAI;AACJ;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;;AAEA;;;;;;;;;;;ACrKA,eAAe,mBAAO,CAAC,yDAAY;;AAEnC;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;;;;;;;;;;;AC7BA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,cAAc,mBAAO,CAAC,uDAAW;;AAEjC;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,UAAU;AACrB,WAAW,UAAU;AACrB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACnBA,aAAa,mBAAO,CAAC,uDAAW;AAChC,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,qBAAqB,mBAAO,CAAC,uEAAmB;;AAEhD;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC3BA,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,mBAAmB,mBAAO,CAAC,iEAAgB;;AAE3C;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACjBA,sBAAsB,mBAAO,CAAC,yEAAoB;AAClD,mBAAmB,mBAAO,CAAC,iEAAgB;;AAE3C;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,WAAW,GAAG;AACd,WAAW,SAAS;AACpB;AACA;AACA,WAAW,UAAU;AACrB,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC3BA,YAAY,mBAAO,CAAC,qDAAU;AAC9B,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,mBAAmB,mBAAO,CAAC,mEAAiB;AAC5C,aAAa,mBAAO,CAAC,uDAAW;AAChC,cAAc,mBAAO,CAAC,uDAAW;AACjC,eAAe,mBAAO,CAAC,yDAAY;AACnC,mBAAmB,mBAAO,CAAC,iEAAgB;;AAE3C;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,UAAU;AACrB,WAAW,UAAU;AACrB,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AClFA,aAAa,mBAAO,CAAC,uDAAW;AAChC,mBAAmB,mBAAO,CAAC,iEAAgB;;AAE3C;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACjBA,iBAAiB,mBAAO,CAAC,6DAAc;AACvC,eAAe,mBAAO,CAAC,2DAAa;AACpC,eAAe,mBAAO,CAAC,yDAAY;AACnC,eAAe,mBAAO,CAAC,2DAAa;;AAEpC;AACA;AACA;AACA;AACA,oCAAoC;;AAEpC;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC9CA,aAAa,mBAAO,CAAC,uDAAW;AAChC,mBAAmB,mBAAO,CAAC,iEAAgB;;AAE3C;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACjBA,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,eAAe,mBAAO,CAAC,yDAAY;AACnC,mBAAmB,mBAAO,CAAC,iEAAgB;;AAE3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC3DA,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC7BA,eAAe,mBAAO,CAAC,yDAAY;AACnC,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,mBAAmB,mBAAO,CAAC,mEAAiB;;AAE5C;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AChCA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,UAAU;AACrB,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACnBA;AACA;AACA;AACA;AACA,WAAW,UAAU;AACrB,aAAa,UAAU;AACvB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACbA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACZA,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA;AACA;AACA;AACA,WAAW,aAAa;AACxB,aAAa,aAAa;AAC1B;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;ACfA,WAAW,mBAAO,CAAC,mDAAS;;AAE5B;AACA,kBAAkB,KAA0B;;AAE5C;AACA,gCAAgC,QAAa;;AAE7C;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,SAAS;AACpB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;;;;;;;;;;AClCA,uBAAuB,mBAAO,CAAC,2EAAqB;;AAEpD;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,SAAS;AACpB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACfA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AChBA,aAAa,mBAAO,CAAC,uDAAW;;AAEhC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACjBA,uBAAuB,mBAAO,CAAC,2EAAqB;;AAEpD;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,SAAS;AACpB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACfA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACnBA,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,sBAAsB,mBAAO,CAAC,yEAAoB;;AAElD;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,OAAO;AAClB,WAAW,QAAQ,UAAU;AAC7B,WAAW,UAAU;AACrB,aAAa,QAAQ;AACrB;AACA;AACA;AACA,wBAAwB;;AAExB;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACvCA,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ,UAAU;AAC7B,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACfA,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,mBAAmB,mBAAO,CAAC,mEAAiB;;AAE5C;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ,UAAU;AAC7B,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACfA,WAAW,mBAAO,CAAC,mDAAS;;AAE5B;AACA;;AAEA;;;;;;;;;;;ACLA,gBAAgB,mBAAO,CAAC,6DAAc;;AAEtC;AACA;AACA;AACA,WAAW,QAAQ;AACnB;AACA,IAAI;AACJ,CAAC;;AAED;;;;;;;;;;;ACVA,eAAe,mBAAO,CAAC,2DAAa;AACpC,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,eAAe,mBAAO,CAAC,2DAAa;;AAEpC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,QAAQ;AACnB,WAAW,UAAU;AACrB,WAAW,UAAU;AACrB,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACnFA,aAAa,mBAAO,CAAC,uDAAW;AAChC,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,SAAS,mBAAO,CAAC,6CAAM;AACvB,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,UAAU;AACrB,WAAW,UAAU;AACrB,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC/GA,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,UAAU;AACrB,WAAW,UAAU;AACrB,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACzFA;AACA,wBAAwB,qBAAM,gBAAgB,qBAAM,IAAI,qBAAM,sBAAsB,qBAAM;;AAE1F;;;;;;;;;;;ACHA,qBAAqB,mBAAO,CAAC,uEAAmB;AAChD,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,WAAW,mBAAO,CAAC,iDAAQ;;AAE3B;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACfA,qBAAqB,mBAAO,CAAC,uEAAmB;AAChD,mBAAmB,mBAAO,CAAC,mEAAiB;AAC5C,aAAa,mBAAO,CAAC,qDAAU;;AAE/B;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AChBA,gBAAgB,mBAAO,CAAC,6DAAc;;AAEtC;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,aAAa,GAAG;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACjBA,mBAAmB,mBAAO,CAAC,mEAAiB;AAC5C,eAAe,mBAAO,CAAC,2DAAa;;AAEpC;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,aAAa,GAAG;AAChB;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AChBA,cAAc,mBAAO,CAAC,yDAAY;;AAElC;AACA;;AAEA;;;;;;;;;;;ACLA,aAAa,mBAAO,CAAC,uDAAW;;AAEhC;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,IAAI;;AAEJ;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC7CA,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,gBAAgB,mBAAO,CAAC,2DAAa;;AAErC;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;;;;;;;;;;;AC7BA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,mBAAmB,mBAAO,CAAC,mEAAiB;AAC5C,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,gBAAgB,mBAAO,CAAC,2DAAa;;AAErC;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACxBA,eAAe,mBAAO,CAAC,2DAAa;AACpC,UAAU,mBAAO,CAAC,iDAAQ;AAC1B,cAAc,mBAAO,CAAC,yDAAY;AAClC,UAAU,mBAAO,CAAC,iDAAQ;AAC1B,cAAc,mBAAO,CAAC,yDAAY;AAClC,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,eAAe,mBAAO,CAAC,2DAAa;;AAEpC;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,QAAQ;AACrB;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACzDA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,aAAa,GAAG;AAChB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACZA,mBAAmB,mBAAO,CAAC,mEAAiB;;AAE5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AChBA,mBAAmB,mBAAO,CAAC,mEAAiB;;AAE5C;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,GAAG;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC7BA,mBAAmB,mBAAO,CAAC,mEAAiB;;AAE5C;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACtBA,mBAAmB,mBAAO,CAAC,mEAAiB;;AAE5C;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,GAAG;AACd,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACtBA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACzBA,uBAAuB,mBAAO,CAAC,2EAAqB;AACpD,oBAAoB,mBAAO,CAAC,qEAAkB;AAC9C,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,sBAAsB,mBAAO,CAAC,yEAAoB;;AAElD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,SAAS;AACpB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC5EA,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,mBAAmB,mBAAO,CAAC,mEAAiB;AAC5C,kBAAkB,mBAAO,CAAC,iEAAgB;;AAE1C;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACjBA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACxBA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACdA,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA,WAAW,UAAU;AACrB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACnBA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;;;;;;;;;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACZA,mBAAmB,mBAAO,CAAC,mEAAiB;;AAE5C;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AClCA,mBAAmB,mBAAO,CAAC,mEAAiB;;AAE5C;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,GAAG;AAChB;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;;;;;;;;;;AClBA,mBAAmB,mBAAO,CAAC,mEAAiB;;AAE5C;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACfA,mBAAmB,mBAAO,CAAC,mEAAiB;;AAE5C;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,GAAG;AACd,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACzBA,WAAW,mBAAO,CAAC,mDAAS;AAC5B,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,UAAU,mBAAO,CAAC,iDAAQ;;AAE1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACpBA,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACjBA,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,GAAG;AAChB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACfA,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACfA,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,GAAG;AACd,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACrBA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;AACA;AACA,GAAG;AACH;AACA;;AAEA;;;;;;;;;;;ACjBA,gBAAgB,mBAAO,CAAC,6DAAc;;AAEtC;AACA;;AAEA;;;;;;;;;;;ACLA,cAAc,mBAAO,CAAC,yDAAY;;AAElC;AACA;;AAEA;;;;;;;;;;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;ACnBA,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA,kBAAkB,KAA0B;;AAE5C;AACA,gCAAgC,QAAa;;AAE7C;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,IAAI;AACJ,CAAC;;AAED;;;;;;;;;;;AC7BA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACrBA;AACA;AACA;AACA;AACA,WAAW,UAAU;AACrB,WAAW,UAAU;AACrB,aAAa,UAAU;AACvB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACdA,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA;;AAEA;AACA;;AAEA;;;;;;;;;;;ACRA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AClBA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACbA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;AACA;AACA,GAAG;AACH;AACA;;AAEA;;;;;;;;;;;ACjBA,gBAAgB,mBAAO,CAAC,6DAAc;;AAEtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;;;;;;;;;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,GAAG;AAChB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACbA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,UAAU,mBAAO,CAAC,iDAAQ;AAC1B,eAAe,mBAAO,CAAC,2DAAa;;AAEpC;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,GAAG;AACd,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACjCA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,UAAU;AACrB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA,MAAM;AACN;AACA;AACA;;AAEA;;;;;;;;;;;ACzBA,gBAAgB,mBAAO,CAAC,6DAAc;;AAEtC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,GAAG;AAChB;AACA;AACA;AACA,oBAAoB,QAAQ,IAAI,QAAQ;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA,kBAAkB;AAClB,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACpCA,sBAAsB,mBAAO,CAAC,yEAAoB;AAClD,mBAAmB,mBAAO,CAAC,iEAAgB;;AAE3C;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA,8BAA8B,mBAAmB;AACjD;AACA;AACA;AACA;AACA;AACA,+CAA+C,mBAAmB;AAClE;AACA;AACA;;AAEA;;;;;;;;;;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACzBA,iBAAiB,mBAAO,CAAC,6DAAc;AACvC,eAAe,mBAAO,CAAC,yDAAY;;AAEnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;AChCA,WAAW,mBAAO,CAAC,mDAAS;AAC5B,gBAAgB,mBAAO,CAAC,2DAAa;;AAErC;AACA,kBAAkB,KAA0B;;AAE5C;AACA,gCAAgC,QAAa;;AAE7C;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACrCA,kBAAkB,mBAAO,CAAC,iEAAgB;;AAE1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA,kBAAkB;AAClB,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AClCA,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,eAAe,mBAAO,CAAC,yDAAY;;AAEnC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACpCA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AClCA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,eAAe,mBAAO,CAAC,2DAAa;;AAEpC;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA,oBAAoB;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC5BA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,eAAe,mBAAO,CAAC,2DAAa;;AAEpC;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC1BA,uBAAuB,mBAAO,CAAC,2EAAqB;AACpD,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,eAAe,mBAAO,CAAC,2DAAa;;AAEpC;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC1BA,oBAAoB,mBAAO,CAAC,qEAAkB;AAC9C,eAAe,mBAAO,CAAC,2DAAa;AACpC,kBAAkB,mBAAO,CAAC,+DAAe;;AAEzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACpCA,oBAAoB,mBAAO,CAAC,qEAAkB;AAC9C,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,kBAAkB,mBAAO,CAAC,+DAAe;;AAEzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;UCjBA;UACA;;UAEA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;;UAEA;UACA;;UAEA;UACA;;UAEA;UACA;UACA;;;;;WCzBA;WACA;WACA;WACA;WACA,GAAG;WACH;WACA;WACA,CAAC;;;;;WCPD;WACA;WACA;WACA,uDAAuD,iBAAiB;WACxE;WACA,gDAAgD,aAAa;WAC7D;;;;;WCNA;WACA;WACA;WACA;WACA;;;;;;;;;;;;;ACHoC;AAEpC,MAAM,WAAW,GAAG,GAAG,8CAAG,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,SAAS,CAAC;AACrD,IAAI,aAAoC,CAAC;AAEzC,MAAM,CAAC,gBAAgB,CAAC,kBAAkB,EAAE,KAAK,IAAI,EAAE;IACtD,MAAM,aAAa,GAAG,QAAQ,CAAC,aAAa,CAAoB,kBAAkB,CAAC,CAAC;IACpF,IAAI,aAAa,EAAE,CAAC;QACnB,aAAa,CAAC,gBAAgB,CAAC,OAAO,EAAE,iBAAiB,CAAC,CAAC;IAC5D,CAAC;IAED,MAAM,aAAa,GAAG,QAAQ,CAAC,aAAa,CAAoB,kBAAkB,CAAC,CAAC;IACpF,IAAI,aAAa,EAAE,CAAC;QACnB,aAAa,CAAC,gBAAgB,CAAC,OAAO,EAAE,iBAAiB,CAAC,CAAC;IAC5D,CAAC;IAED,MAAM,eAAe,GAAG,QAAQ,CAAC,aAAa,CAAoB,gBAAgB,CAAC,CAAC;IACpF,IAAI,eAAe,EAAE,CAAC;QACrB,eAAe,CAAC,gBAAgB,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;IACzD,CAAC;IACD,MAAM,kBAAkB,EAAE,CAAC;AAC5B,CAAC,CAAC,CAAC;AAEH;;GAEG;AACH,KAAK,UAAU,iBAAiB;IAC/B,MAAM,UAAU,GAAG,QAAQ,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;IACtD,IAAI,CAAC;QACJ,MAAM,OAAO,GAAG,qCAAqC,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC;QAClE,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QACrB,IAAI,UAAU,EAAE,CAAC;YAChB,UAAU,CAAC,WAAW,IAAI;;GAE1B,OAAO,GAAG,CAAC;QACZ,CAAC;IACF,CAAC;IAAC,OAAO,GAAY,EAAE,CAAC;QACvB,IAAI,UAAU,EAAE,CAAC;YAChB,UAAU,CAAC,WAAW,IAAI,kCAAmC,GAAa,CAAC,OAAO,EAAE,CAAC;QACtF,CAAC;IACF,CAAC;AACF,CAAC;AAED;;GAEG;AACH,KAAK,UAAU,iBAAiB;IAC/B,MAAM,UAAU,GAAG,QAAQ,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;IACtD,IAAI,CAAC;QACJ,MAAM,OAAO,GAAG,qCAAqC,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC;QAClE,IAAI,UAAU,EAAE,CAAC;YAChB,UAAU,CAAC,WAAW,IAAI;;GAE1B,OAAO,GAAG,CAAC;QACZ,CAAC;QACD,MAAM,aAAa,CAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAC9C,CAAC;IAAC,OAAO,GAAY,EAAE,CAAC;QACvB,IAAI,UAAU,EAAE,CAAC;YAChB,UAAU,CAAC,WAAW,IAAI,8CAA+C,GAAa,CAAC,OAAO,EAAE,CAAC;QAClG,CAAC;IACF,CAAC;AACF,CAAC;AAED;;GAEG;AACH,KAAK,UAAU,kBAAkB;IAChC,IAAI,aAAa,KAAK,SAAS,EAAE,CAAC;QACjC,aAAa,GAAG,MAAM,8CAAG,CAAC,mBAAmB,CAAC,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;IAC5E,CAAC;AACF,CAAC;AAED;;GAEG;AACH,SAAS,YAAY;IACpB,MAAM,UAAU,GAAG,QAAQ,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;IACtD,IAAI,UAAU,EAAE,CAAC;QAChB,UAAU,CAAC,WAAW,GAAG,EAAE,CAAC;IAC7B,CAAC;AACF,CAAC","sources":["webpack://use-logging-apis/../../node_modules/@openfin/core/out/mock.js","webpack://use-logging-apis/../../node_modules/events/events.js","webpack://use-logging-apis/../../node_modules/lodash/_DataView.js","webpack://use-logging-apis/../../node_modules/lodash/_Hash.js","webpack://use-logging-apis/../../node_modules/lodash/_ListCache.js","webpack://use-logging-apis/../../node_modules/lodash/_Map.js","webpack://use-logging-apis/../../node_modules/lodash/_MapCache.js","webpack://use-logging-apis/../../node_modules/lodash/_Promise.js","webpack://use-logging-apis/../../node_modules/lodash/_Set.js","webpack://use-logging-apis/../../node_modules/lodash/_SetCache.js","webpack://use-logging-apis/../../node_modules/lodash/_Stack.js","webpack://use-logging-apis/../../node_modules/lodash/_Symbol.js","webpack://use-logging-apis/../../node_modules/lodash/_Uint8Array.js","webpack://use-logging-apis/../../node_modules/lodash/_WeakMap.js","webpack://use-logging-apis/../../node_modules/lodash/_arrayEach.js","webpack://use-logging-apis/../../node_modules/lodash/_arrayFilter.js","webpack://use-logging-apis/../../node_modules/lodash/_arrayLikeKeys.js","webpack://use-logging-apis/../../node_modules/lodash/_arrayPush.js","webpack://use-logging-apis/../../node_modules/lodash/_arraySome.js","webpack://use-logging-apis/../../node_modules/lodash/_assignValue.js","webpack://use-logging-apis/../../node_modules/lodash/_assocIndexOf.js","webpack://use-logging-apis/../../node_modules/lodash/_baseAssign.js","webpack://use-logging-apis/../../node_modules/lodash/_baseAssignIn.js","webpack://use-logging-apis/../../node_modules/lodash/_baseAssignValue.js","webpack://use-logging-apis/../../node_modules/lodash/_baseClone.js","webpack://use-logging-apis/../../node_modules/lodash/_baseCreate.js","webpack://use-logging-apis/../../node_modules/lodash/_baseGetAllKeys.js","webpack://use-logging-apis/../../node_modules/lodash/_baseGetTag.js","webpack://use-logging-apis/../../node_modules/lodash/_baseIsArguments.js","webpack://use-logging-apis/../../node_modules/lodash/_baseIsEqual.js","webpack://use-logging-apis/../../node_modules/lodash/_baseIsEqualDeep.js","webpack://use-logging-apis/../../node_modules/lodash/_baseIsMap.js","webpack://use-logging-apis/../../node_modules/lodash/_baseIsNative.js","webpack://use-logging-apis/../../node_modules/lodash/_baseIsSet.js","webpack://use-logging-apis/../../node_modules/lodash/_baseIsTypedArray.js","webpack://use-logging-apis/../../node_modules/lodash/_baseKeys.js","webpack://use-logging-apis/../../node_modules/lodash/_baseKeysIn.js","webpack://use-logging-apis/../../node_modules/lodash/_baseTimes.js","webpack://use-logging-apis/../../node_modules/lodash/_baseUnary.js","webpack://use-logging-apis/../../node_modules/lodash/_cacheHas.js","webpack://use-logging-apis/../../node_modules/lodash/_cloneArrayBuffer.js","webpack://use-logging-apis/../../node_modules/lodash/_cloneBuffer.js","webpack://use-logging-apis/../../node_modules/lodash/_cloneDataView.js","webpack://use-logging-apis/../../node_modules/lodash/_cloneRegExp.js","webpack://use-logging-apis/../../node_modules/lodash/_cloneSymbol.js","webpack://use-logging-apis/../../node_modules/lodash/_cloneTypedArray.js","webpack://use-logging-apis/../../node_modules/lodash/_copyArray.js","webpack://use-logging-apis/../../node_modules/lodash/_copyObject.js","webpack://use-logging-apis/../../node_modules/lodash/_copySymbols.js","webpack://use-logging-apis/../../node_modules/lodash/_copySymbolsIn.js","webpack://use-logging-apis/../../node_modules/lodash/_coreJsData.js","webpack://use-logging-apis/../../node_modules/lodash/_defineProperty.js","webpack://use-logging-apis/../../node_modules/lodash/_equalArrays.js","webpack://use-logging-apis/../../node_modules/lodash/_equalByTag.js","webpack://use-logging-apis/../../node_modules/lodash/_equalObjects.js","webpack://use-logging-apis/../../node_modules/lodash/_freeGlobal.js","webpack://use-logging-apis/../../node_modules/lodash/_getAllKeys.js","webpack://use-logging-apis/../../node_modules/lodash/_getAllKeysIn.js","webpack://use-logging-apis/../../node_modules/lodash/_getMapData.js","webpack://use-logging-apis/../../node_modules/lodash/_getNative.js","webpack://use-logging-apis/../../node_modules/lodash/_getPrototype.js","webpack://use-logging-apis/../../node_modules/lodash/_getRawTag.js","webpack://use-logging-apis/../../node_modules/lodash/_getSymbols.js","webpack://use-logging-apis/../../node_modules/lodash/_getSymbolsIn.js","webpack://use-logging-apis/../../node_modules/lodash/_getTag.js","webpack://use-logging-apis/../../node_modules/lodash/_getValue.js","webpack://use-logging-apis/../../node_modules/lodash/_hashClear.js","webpack://use-logging-apis/../../node_modules/lodash/_hashDelete.js","webpack://use-logging-apis/../../node_modules/lodash/_hashGet.js","webpack://use-logging-apis/../../node_modules/lodash/_hashHas.js","webpack://use-logging-apis/../../node_modules/lodash/_hashSet.js","webpack://use-logging-apis/../../node_modules/lodash/_initCloneArray.js","webpack://use-logging-apis/../../node_modules/lodash/_initCloneByTag.js","webpack://use-logging-apis/../../node_modules/lodash/_initCloneObject.js","webpack://use-logging-apis/../../node_modules/lodash/_isIndex.js","webpack://use-logging-apis/../../node_modules/lodash/_isKeyable.js","webpack://use-logging-apis/../../node_modules/lodash/_isMasked.js","webpack://use-logging-apis/../../node_modules/lodash/_isPrototype.js","webpack://use-logging-apis/../../node_modules/lodash/_listCacheClear.js","webpack://use-logging-apis/../../node_modules/lodash/_listCacheDelete.js","webpack://use-logging-apis/../../node_modules/lodash/_listCacheGet.js","webpack://use-logging-apis/../../node_modules/lodash/_listCacheHas.js","webpack://use-logging-apis/../../node_modules/lodash/_listCacheSet.js","webpack://use-logging-apis/../../node_modules/lodash/_mapCacheClear.js","webpack://use-logging-apis/../../node_modules/lodash/_mapCacheDelete.js","webpack://use-logging-apis/../../node_modules/lodash/_mapCacheGet.js","webpack://use-logging-apis/../../node_modules/lodash/_mapCacheHas.js","webpack://use-logging-apis/../../node_modules/lodash/_mapCacheSet.js","webpack://use-logging-apis/../../node_modules/lodash/_mapToArray.js","webpack://use-logging-apis/../../node_modules/lodash/_nativeCreate.js","webpack://use-logging-apis/../../node_modules/lodash/_nativeKeys.js","webpack://use-logging-apis/../../node_modules/lodash/_nativeKeysIn.js","webpack://use-logging-apis/../../node_modules/lodash/_nodeUtil.js","webpack://use-logging-apis/../../node_modules/lodash/_objectToString.js","webpack://use-logging-apis/../../node_modules/lodash/_overArg.js","webpack://use-logging-apis/../../node_modules/lodash/_root.js","webpack://use-logging-apis/../../node_modules/lodash/_setCacheAdd.js","webpack://use-logging-apis/../../node_modules/lodash/_setCacheHas.js","webpack://use-logging-apis/../../node_modules/lodash/_setToArray.js","webpack://use-logging-apis/../../node_modules/lodash/_stackClear.js","webpack://use-logging-apis/../../node_modules/lodash/_stackDelete.js","webpack://use-logging-apis/../../node_modules/lodash/_stackGet.js","webpack://use-logging-apis/../../node_modules/lodash/_stackHas.js","webpack://use-logging-apis/../../node_modules/lodash/_stackSet.js","webpack://use-logging-apis/../../node_modules/lodash/_toSource.js","webpack://use-logging-apis/../../node_modules/lodash/cloneDeep.js","webpack://use-logging-apis/../../node_modules/lodash/eq.js","webpack://use-logging-apis/../../node_modules/lodash/isArguments.js","webpack://use-logging-apis/../../node_modules/lodash/isArray.js","webpack://use-logging-apis/../../node_modules/lodash/isArrayLike.js","webpack://use-logging-apis/../../node_modules/lodash/isBuffer.js","webpack://use-logging-apis/../../node_modules/lodash/isEqual.js","webpack://use-logging-apis/../../node_modules/lodash/isFunction.js","webpack://use-logging-apis/../../node_modules/lodash/isLength.js","webpack://use-logging-apis/../../node_modules/lodash/isMap.js","webpack://use-logging-apis/../../node_modules/lodash/isObject.js","webpack://use-logging-apis/../../node_modules/lodash/isObjectLike.js","webpack://use-logging-apis/../../node_modules/lodash/isSet.js","webpack://use-logging-apis/../../node_modules/lodash/isTypedArray.js","webpack://use-logging-apis/../../node_modules/lodash/keys.js","webpack://use-logging-apis/../../node_modules/lodash/keysIn.js","webpack://use-logging-apis/../../node_modules/lodash/stubArray.js","webpack://use-logging-apis/../../node_modules/lodash/stubFalse.js","webpack://use-logging-apis/webpack/bootstrap","webpack://use-logging-apis/webpack/runtime/global","webpack://use-logging-apis/webpack/runtime/make namespace object","webpack://use-logging-apis/webpack/runtime/node module decorator","webpack://use-logging-apis/./client/src/app.ts"],"sourcesContent":["'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar require$$0 = require('events');\nvar require$$0$1 = require('lodash/cloneDeep');\nvar require$$3 = require('lodash/isEqual');\n\nfunction _mergeNamespaces(n, m) {\n\tm.forEach(function (e) {\n\t\te && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {\n\t\t\tif (k !== 'default' && !(k in n)) {\n\t\t\t\tvar d = Object.getOwnPropertyDescriptor(e, k);\n\t\t\t\tObject.defineProperty(n, k, d.get ? d : {\n\t\t\t\t\tenumerable: true,\n\t\t\t\t\tget: function () { return e[k]; }\n\t\t\t\t});\n\t\t\t}\n\t\t});\n\t});\n\treturn Object.freeze(n);\n}\n\nvar commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};\n\nfunction getDefaultExportFromCjs (x) {\n\treturn x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;\n}\n\nvar OpenFin$2 = {};\n\nvar events = {};\n\nvar application$1 = {};\n\n/**\n * Namespace for events that can be emitted by an {@link OpenFin.Application}.  Includes events\n * re-propagated from the {@link OpenFin.Window} (and, transitively, {@link OpenFin.View}) level, prefixed with `window-` (and also, if applicable, `view-`).\n * For example, a view's \"attached\" event will fire as 'window-view-attached' at the application level.\n *\n * Event payloads are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.\n * Events gain metadata as they propagate, which is *not* present on the explicit payload interfaces.  To refer to the full type\n * of an event as it would be raised on this emitter, use {@link Payload}.\n *\n * This namespace contains only payload shapes for events that are unique to `Application`.  Events that propagate to `Application` from\n * child {@link OpenFin.Window windows} and {@link OpenFin.View views} are defined in the {@link OpenFin.WindowEvents} and\n * {@link OpenFin.ViewEvents} namespaces.  For a list of valid string keys for *all* application events, see {@link Application.on Application.on}.\n *\n * {@link ApplicationSourcedEvent Application-sourced events} (i.e. those that have not propagated from {@link OpenFin.ViewEvents Views}\n * or {@link OpenFin.WindowEvents Windows} re-propagate to {@link OpenFin.SystemEvents System} with their type string prefixed with `application-`.\n * {@link ApplicationWindowEvent Application events that are tied to Windows but do not propagate from them}\n * are propagated to `System` without any type string prefixing.\n *\n * \"Requested\" events (e.g. {@link RunRequestedEvent}) do not propagate.\n *\n * @packageDocumentation\n */\nObject.defineProperty(application$1, \"__esModule\", { value: true });\n\nvar base$1 = {};\n\n/**\n * Namespace for shared event payloads and utility types common to all event emitters.\n *\n * @packageDocumentation\n */\nObject.defineProperty(base$1, \"__esModule\", { value: true });\n\nvar externalApplication$1 = {};\n\n/**\n * Namespace for events that can be transmitted by an {@link OpenFin.ExternalApplication}.\n *\n * Event payloads are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.\n * Events gain metadata as they propagate, which is *not* present on the explicit payload interfaces.  To refer to the full type\n * of an event as it would be raised on this emitter, use {@link Payload}.\n *\n * For a list of valid string keys for external application events, see {@link ExternalApplication.on ExternalApplication.on}.\n *\n * @packageDocumentation\n */\nObject.defineProperty(externalApplication$1, \"__esModule\", { value: true });\n\nvar frame$1 = {};\n\nObject.defineProperty(frame$1, \"__esModule\", { value: true });\n\nvar globalHotkey$1 = {};\n\n/**\n *\n * Namespace for events that can be transmitted by {@link GlobalHotkey.GlobalHotkey}.\n *\n * Event payloads are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.\n * Events gain metadata as they propagate, which is *not* present on the explicit payload interfaces.  To refer to the full type\n * of an event as it would be raised on this emitter, use {@link Payload}.\n *\n * For a list of valid string keys for global hotkey events, see {@link GlobalHotkey.GlobalHotkey.on GlobalHotkey.on}.\n *\n * @packageDocumentation\n */\nObject.defineProperty(globalHotkey$1, \"__esModule\", { value: true });\n\nvar platform$1 = {};\n\n/**\n *\n * Namespace for events that can emitted by a {@link OpenFin.Platform}.\n *\n * Event payloads are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.\n * Events gain metadata as they propagate, which is *not* present on the explicit payload interfaces.  To refer to the full type\n * of an event as it would be raised on this emitter, use {@link Payload}.\n *\n * The Platform `EventEmitter` is a superset of the {@link OpenFin.Application} `EventEmitter`,\n * meaning it can listen to all {@link OpenFin.ApplicationEvents Application events} in addition to the\n * Platform-specific events listed here.  For a list of valid string keys for *all* platform events, see\n * {@link Platform.on Platform.on}.\n *\n * @packageDocumentation\n */\nObject.defineProperty(platform$1, \"__esModule\", { value: true });\n\nvar system$1 = {};\n\n/**\n * Namespace for runtime-wide OpenFin events emitted by {@link System.System}.  Includes events\n * re-propagated from {@link OpenFin.Application}, {@link OpenFin.Window}, and {@link OpenFin.View} (prefixed with `application-`, `window-`, and `view-`).  All\n * event propagations are visible at the System level. Propagated events from WebContents (windows, views, frames) to the Application level will *not*\n * transitively re-propagate to the System level, because they are already visible at the system level and contain the identity\n * of the application.  For example, an application's \"closed\" event will fire as 'application-closed' at the system level.  A view's 'shown' event\n * will be visible as 'view-shown' at the system level, but *not* as `application-window-view-shown`.\n *\n * Event payloads are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.\n * Events gain metadata as they propagate, which is *not* present on the explicit payload interfaces.  To refer to the full type\n * of an event as it would be raised on this emitter, use {@link Payload}.\n *\n * This namespace contains only payload shapes for events that are unique to `System`.  Events that propagate to `System` from\n * child {@link OpenFin.Application applications}, {@link OpenFin.Window windows}, and {@link OpenFin.View views} are defined in the\n * {@link OpenFin.ApplicationEvents}, {@link OpenFin.WindowEvents}, and {@link OpenFin.ViewEvents} namespaces.  For a list of valid string keys for *all*\n * system events, see {@link System.on System.on}.\n *\n * @packageDocumentation\n */\nObject.defineProperty(system$1, \"__esModule\", { value: true });\n\nvar view$1 = {};\n\n/**\n * Namespace for events that can be emitted by a {@link OpenFin.View}.\n *\n * Event payloads are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.\n * Events gain metadata as they propagate, which is *not* present on the explicit payload interfaces.  To refer to the full type\n * of an event as it would be raised on this emitter, use {@link Payload}.\n *\n * This namespace contains only payload shapes for events that are unique to `View`.  Events that are shared between all `WebContents`\n * (i.e. {@link OpenFin.Window}, {@link OpenFin.View}) are defined in {@link OpenFin.WebContentsEvents}.  For a list\n * of valid string keys for *all* View events, see {@link View.on View.on}.\n *\n * View events propagate to their parent {@link OpenFin.WindowEvents Window}, {@link OpenFin.ApplicationEvents Application},\n * and {@link OpenFin.SystemEvents System} with an added `viewIdentity` property and their event types prefixed with `'view-'`.\n *\n * @packageDocumentation\n */\nObject.defineProperty(view$1, \"__esModule\", { value: true });\n\nvar webcontents = {};\n\n/**\n * Namespace for events shared by all OpenFin WebContents elements (i.e. {@link OpenFin.Window},\n * {@link OpenFin.View}).\n *\n * WebContents events will re-emit on parent entities - e.g., a propagating event in a view will also be emitted on the view's\n * parent window, and propagating events in a window will also be emitted on the window's parent {@link OpenFin.Application}.\n *\n * @packageDocumentation\n */\nObject.defineProperty(webcontents, \"__esModule\", { value: true });\n\nvar window$2 = {};\n\n/**\n * Namespace for events that can be emitted by a {@link OpenFin.Window}.\n *\n * Event payloads are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.\n * Events gain metadata as they propagate, which is *not* present on the explicit payload interfaces.  To refer to the full type\n * of an event as it would be raised on this emitter, use {@link Payload}.\n *\n * This namespace contains only payload shapes for events that are unique to `Window`.  Events that are shared between all `WebContents`\n * (i.e. {@link OpenFin.Window}, {@link OpenFin.View}) are defined in {@link OpenFin.WebContentsEvents}. Events that\n * propagate from `View` are defined in {@link OpenFin.ViewEvents}. For a list of valid string keys for *all* Window events, see\n * {@link Window.on Window.on}\n *\n * {@link OpenFin.WindowEvents.WindowSourcedEvent Window-sourced events} (i.e. those that are not propagated from a\n * {@link OpenFin.ViewEvents View}) propagate to their parent {@link OpenFin.ApplicationEvents Application} and\n * {@link OpenFin.SystemEvents System} with their event types prefixed with `'window-'`).\n *\n * \"Requested\" events (e.g. {@link AuthRequestedEvent}) do not propagate to `System.  The {@link OpenFin.WindowEvents.WindowCloseRequestedEvent}\n * does not propagate at all.\n *\n * @packageDocumentation\n */\nObject.defineProperty(window$2, \"__esModule\", { value: true });\n\n/**\n * Namespace for OpenFin event types. Each entity that emits OpenFin events has its own sub-namespace. Event payloads\n * themselves are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.\n *\n * #### Event emitters\n *\n * The following entities emit OpenFin events, and have corresponding sub-namespaces:\n *\n * * {@link OpenFin.Application}: {@link OpenFin.ApplicationEvents}\n * * {@link OpenFin.ExternalApplication}: {@link OpenFin.ExternalApplicationEvents}\n * * {@link OpenFin.Frame}: {@link OpenFin.FrameEvents}\n * * {@link OpenFin.GlobalHotkey}: {@link OpenFin.GlobalHotkeyEvents}\n * * {@link OpenFin.Platform}: {@link OpenFin.PlatformEvents}\n * * {@link OpenFin.System}: {@link OpenFin.SystemEvents}\n * * {@link OpenFin.View}: {@link OpenFin.ViewEvents}\n * * {@link OpenFin.Window}: {@link OpenFin.WindowEvents}\n *\n * These `EventEmitter` entities share a common set of methods for interacting with the OpenFin event bus, which can be\n * seen on the individual documentation pages for each entity type.\n *\n * Registering event handlers is an asynchronous operation. It is important to ensure that the returned Promises are awaited to reduce the\n * risk of race conditions.\n *\n * When the `EventEmitter` receives an event from the browser process and emits on the renderer, all of the functions attached to that\n * specific event are called synchronously. Any values returned by the called listeners are ignored and will be discarded.  If the window document\n * is destroyed by page navigation or reload, its registered event listeners will be removed.\n *\n * We recommend using Arrow Functions for event listeners to ensure the this scope is consistent with the original function context.\n *\n * Events re-propagate from smaller/more-local scopes to larger/more-global scopes.  For example, an event emitted on a specific\n * view will propagate to the window in which the view is embedded, and then to the application in which the window is running, and\n * finally to the OpenFin runtime itself at the \"system\" level.  For details on propagation semantics, see the namespace for\n * the propagating (or propagated-to) entity.\n *\n * If you need the payload type for a specific type of event (especially propagated events), use the emitting topic's `Payload` generic\n * (e.g. {@link WindowEvents.Payload}) with the event's `type` string.  For example, the payload of\n * a {@link ViewEvents.CreatedEvent} after it has propagated to its parent {@link WindowEvents Window} can be found with\n * `WindowEvents.Payload<'view-created'>`.\n *\n * @packageDocumentation\n */\nvar __createBinding$1 = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault$1 = (commonjsGlobal && commonjsGlobal.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar$1 = (commonjsGlobal && commonjsGlobal.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding$1(result, mod, k);\n    __setModuleDefault$1(result, mod);\n    return result;\n};\nObject.defineProperty(events, \"__esModule\", { value: true });\nevents.WindowEvents = events.WebContentsEvents = events.ViewEvents = events.SystemEvents = events.PlatformEvents = events.GlobalHotkeyEvents = events.FrameEvents = events.ExternalApplicationEvents = events.BaseEvents = events.ApplicationEvents = void 0;\nconst ApplicationEvents = __importStar$1(application$1);\nevents.ApplicationEvents = ApplicationEvents;\nconst BaseEvents = __importStar$1(base$1);\nevents.BaseEvents = BaseEvents;\nconst ExternalApplicationEvents = __importStar$1(externalApplication$1);\nevents.ExternalApplicationEvents = ExternalApplicationEvents;\nconst FrameEvents = __importStar$1(frame$1);\nevents.FrameEvents = FrameEvents;\nconst GlobalHotkeyEvents = __importStar$1(globalHotkey$1);\nevents.GlobalHotkeyEvents = GlobalHotkeyEvents;\nconst PlatformEvents = __importStar$1(platform$1);\nevents.PlatformEvents = PlatformEvents;\nconst SystemEvents = __importStar$1(system$1);\nevents.SystemEvents = SystemEvents;\nconst ViewEvents = __importStar$1(view$1);\nevents.ViewEvents = ViewEvents;\nconst WebContentsEvents = __importStar$1(webcontents);\nevents.WebContentsEvents = WebContentsEvents;\nconst WindowEvents = __importStar$1(window$2);\nevents.WindowEvents = WindowEvents;\n\n(function (exports) {\n\t/**\n\t * Top-level namespace for types referenced by the OpenFin API.  Contains:\n\t *\n\t * * The type of the global `fin` entry point ({@link FinApi})\n\t * * Classes that act as static namespaces returned from the `fin` global (e.g. {@link ApplicationModule}, accessible via `fin.Application`)\n\t * * Instance classes that are returned from API calls (e.g. {@link Application}, accessible via `fin.Application.getCurrentSync()`)\n\t * * Parameter shapes for API methods (e.g. {@link ApplicationOptions}, used in `fin.Application.start()`)\n\t * * Event namespaces and payload union types (e.g. {@link ApplicationEvents} and {@link ApplicationEvent})\n\t *\n\t * @packageDocumentation\n\t */\n\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t    }\n\t    Object.defineProperty(o, k2, desc);\n\t}) : (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    o[k2] = m[k];\n\t}));\n\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t};\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t// Deprecated shim to preserve v30 namespace names\n\t__exportStar(events, exports); \n} (OpenFin$2));\n\nvar OpenFin = /*@__PURE__*/getDefaultExportFromCjs(OpenFin$2);\n\nvar OpenFin$1 = /*#__PURE__*/_mergeNamespaces({\n\t__proto__: null,\n\tdefault: OpenFin\n}, [OpenFin$2]);\n\nvar fin$2 = {};\n\nvar system = {};\n\nvar base = {};\n\nvar promises = {};\n\nObject.defineProperty(promises, \"__esModule\", { value: true });\npromises.promiseMapSerial = promises.serial = promises.promiseMap = promises.promisify = void 0;\nfunction promisify(func) {\n    return (...args) => new Promise((resolve, reject) => {\n        func(...args, (err, val) => (err ? reject(err) : resolve(val)));\n    });\n}\npromises.promisify = promisify;\nasync function promiseMap(arr, asyncF) {\n    return Promise.all(arr.map(asyncF));\n}\npromises.promiseMap = promiseMap;\nasync function serial(arr) {\n    const ret = [];\n    for (const func of arr) {\n        // eslint-disable-next-line no-await-in-loop\n        const next = await func();\n        ret.push(next);\n    }\n    return ret;\n}\npromises.serial = serial;\nasync function promiseMapSerial(arr, func) {\n    return serial(arr.map((value, index, array) => () => func(value, index, array)));\n}\npromises.promiseMapSerial = promiseMapSerial;\n\nvar __classPrivateFieldSet$c = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar __classPrivateFieldGet$e = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar _EmitterBase_emitterAccessor;\nObject.defineProperty(base, \"__esModule\", { value: true });\nbase.Reply = base.EmitterBase = base.Base = void 0;\nconst promises_1 = promises;\nclass Base {\n    /**\n     * @internal\n     */\n    constructor(wire) {\n        /**\n         * @internal\n         * @deprecated\n         */\n        this.isNodeEnvironment = () => {\n            return this.wire.environment.type === 'node';\n        };\n        /**\n         * @internal\n         * @deprecated\n         */\n        this.isOpenFinEnvironment = () => {\n            return this.wire.environment.type === 'openfin';\n        };\n        /**\n         * @internal\n         * @deprecated\n         */\n        this.isBrowserEnvironment = () => {\n            return this.wire.environment.type === 'other';\n        };\n        this.wire = wire;\n    }\n    get fin() {\n        return this.wire.getFin();\n    }\n    /**\n     * Provides access to the OpenFin representation of the current code context (usually a document\n     * such as a {@link OpenFin.View} or {@link OpenFin.Window}), as well as to the current `Interop` context.\n     *\n     * Useful for debugging in the devtools console, where this will intelligently type itself based\n     * on the context in which the devtools panel was opened.\n     */\n    get me() {\n        return this.wire.me;\n    }\n}\nbase.Base = Base;\n/**\n * An entity that emits OpenFin events.\n *\n * @remarks Event-binding methods are asynchronous as they must cross process boundaries\n * and setup the listener in the browser process.  When the `EventEmitter` receives an event from the browser process\n * and emits on the renderer, all of the functions attached to that specific event are called synchronously.  Any values\n * returned by the called listeners are ignored and will be discarded.  If the execution context of the window is destroyed\n * by page navigation or reload, any events that have been setup in that context will be destroyed.\n *\n * It is important to keep in mind that when an ordinary listener function is called, the standard `this` keyword is intentionally\n * set to reference the `EventEmitter` instance to which the listener is attached.  It is possible to use ES6 Arrow Functions as\n * listeners, however, when doing so, the `this` keyword will no longer reference the `EventEmitter` instance.\n *\n * Events re-propagate from smaller/more-local scopes to larger/more-global scopes.  For example, an event emitted on a specific\n * view will propagate to the window in which the view is embedded, and then to the application in which the window is running, and\n * finally to the OpenFin runtime itself at the \"system\" level.  Re-propagated events are prefixed with the name of the scope in which\n * they originated - for example, a \"shown\" event emitted on a view will be re-propagated at the window level as \"view-shown\", and\n * then to the application as \"window-view-shown\", and finally at the system level as \"application-window-view-shown\".\n *\n * All event propagations are visible at the System level, regardless of source, so transitive re-propagations (e.g. from view to window\n * to application) are visible in their entirety at the system level.  So, we can listen to the above event as \"shown\", \"view-shown\",\n * \"window-view-shown\", or \"application-window-view-shown.\"\n */\nclass EmitterBase extends Base {\n    constructor(wire, topic, ...additionalAccessors) {\n        super(wire);\n        this.topic = topic;\n        _EmitterBase_emitterAccessor.set(this, void 0);\n        this.eventNames = () => (this.hasEmitter() ? this.getOrCreateEmitter().eventNames() : []);\n        /**\n         * @internal\n         */\n        this.emit = (eventType, payload, ...args) => {\n            return this.hasEmitter() ? this.getOrCreateEmitter().emit(eventType, payload, ...args) : false;\n        };\n        this.hasEmitter = () => this.wire.eventAggregator.has(__classPrivateFieldGet$e(this, _EmitterBase_emitterAccessor, \"f\"));\n        this.getOrCreateEmitter = () => this.wire.eventAggregator.getOrCreate(__classPrivateFieldGet$e(this, _EmitterBase_emitterAccessor, \"f\"));\n        this.listeners = (type) => this.hasEmitter() ? this.getOrCreateEmitter().listeners(type) : [];\n        this.listenerCount = (type) => this.hasEmitter() ? this.getOrCreateEmitter().listenerCount(type) : 0;\n        this.registerEventListener = async (eventType, options = {}, applySubscription, undoSubscription) => {\n            const runtimeEvent = {\n                ...this.identity,\n                timestamp: options.timestamp || Date.now(),\n                topic: this.topic,\n                type: eventType\n            };\n            const emitter = this.getOrCreateEmitter();\n            // We apply the subscription and then undo if the async call fails to avoid\n            // indeterminacy in subscription application order, which can break things elsewhere\n            applySubscription(emitter);\n            try {\n                await this.wire.sendAction('subscribe-to-desktop-event', runtimeEvent);\n            }\n            catch (e) {\n                undoSubscription(emitter);\n                this.deleteEmitterIfNothingRegistered(emitter);\n                throw e;\n            }\n        };\n        this.deregisterEventListener = async (eventType, options = {}) => {\n            if (this.hasEmitter()) {\n                const runtimeEvent = {\n                    ...this.identity,\n                    timestamp: options.timestamp || Date.now(),\n                    topic: this.topic,\n                    type: eventType\n                };\n                await this.wire.sendAction('unsubscribe-to-desktop-event', runtimeEvent).catch(() => null);\n                const emitter = this.getOrCreateEmitter();\n                return emitter;\n            }\n            // This will only be reached if unsubscribe from event that does not exist but do not want to error here\n            return Promise.resolve();\n        };\n        __classPrivateFieldSet$c(this, _EmitterBase_emitterAccessor, [topic, ...additionalAccessors], \"f\");\n        this.listeners = (event) => this.hasEmitter() ? this.getOrCreateEmitter().listeners(event) : [];\n    }\n    /**\n     * Adds a listener to the end of the listeners array for the specified event.\n     *\n     * @remarks Event payloads are documented in the {@link OpenFin.Events} namespace.\n     */\n    async on(eventType, listener, options) {\n        await this.registerEventListener(eventType, options, (emitter) => {\n            emitter.on(eventType, listener);\n        }, (emitter) => {\n            emitter.removeListener(eventType, listener);\n        });\n        return this;\n    }\n    /**\n     * Adds a listener to the end of the listeners array for the specified event.\n     */\n    async addListener(eventType, listener, options) {\n        return this.on(eventType, listener, options);\n    }\n    /**\n     * Adds a one time listener for the event. The listener is invoked only the first time the event is fired, after which it is removed.\n     *\n     * @remarks Event payloads are documented in the {@link OpenFin.Events} namespace.\n     */\n    async once(eventType, listener, options) {\n        const deregister = () => this.deregisterEventListener(eventType);\n        await this.registerEventListener(eventType, options, (emitter) => {\n            emitter.once(eventType, deregister);\n            emitter.once(eventType, listener);\n        }, (emitter) => {\n            emitter.removeListener(eventType, deregister);\n            emitter.removeListener(eventType, listener);\n        });\n        return this;\n    }\n    /**\n     * Adds a listener to the beginning of the listeners array for the specified event.\n     *\n     * @remarks Event payloads are documented in the {@link OpenFin.Events} namespace.\n     */\n    async prependListener(eventType, listener, options) {\n        await this.registerEventListener(eventType, options, (emitter) => {\n            emitter.prependListener(eventType, listener);\n        }, (emitter) => {\n            emitter.removeListener(eventType, listener);\n        });\n        return this;\n    }\n    /**\n     * Adds a one time listener for the event. The listener is invoked only the first time the event is fired,\n     * after which it is removed. The listener is added to the beginning of the listeners array.\n     *\n     * @remarks Event payloads are documented in the {@link OpenFin.Events} namespace.\n     */\n    async prependOnceListener(eventType, listener, options) {\n        const deregister = () => this.deregisterEventListener(eventType);\n        await this.registerEventListener(eventType, options, (emitter) => {\n            emitter.prependOnceListener(eventType, listener);\n            emitter.once(eventType, deregister);\n        }, (emitter) => {\n            emitter.removeListener(eventType, listener);\n            emitter.removeListener(eventType, deregister);\n        });\n        return this;\n    }\n    /**\n     * Remove a listener from the listener array for the specified event.\n     *\n     * @remarks Caution: Calling this method changes the array indices in the listener array behind the listener.\n     */\n    async removeListener(eventType, listener, options) {\n        const emitter = await this.deregisterEventListener(eventType, options);\n        if (emitter) {\n            emitter.removeListener(eventType, listener);\n            this.deleteEmitterIfNothingRegistered(emitter);\n        }\n        return this;\n    }\n    async deregisterAllListeners(eventType) {\n        const runtimeEvent = { ...this.identity, type: eventType, topic: this.topic };\n        if (this.hasEmitter()) {\n            const emitter = this.getOrCreateEmitter();\n            const refCount = emitter.listenerCount(runtimeEvent.type);\n            const unsubscribePromises = [];\n            for (let i = 0; i < refCount; i++) {\n                unsubscribePromises.push(this.wire.sendAction('unsubscribe-to-desktop-event', runtimeEvent).catch(() => null));\n            }\n            await Promise.all(unsubscribePromises);\n            return emitter;\n        }\n        return undefined;\n    }\n    /**\n     * Removes all listeners, or those of the specified event.\n     *\n     */\n    async removeAllListeners(eventType) {\n        const removeByEvent = async (event) => {\n            const emitter = await this.deregisterAllListeners(event);\n            if (emitter) {\n                emitter.removeAllListeners(event);\n                this.deleteEmitterIfNothingRegistered(emitter);\n            }\n        };\n        if (eventType) {\n            await removeByEvent(eventType);\n        }\n        else if (this.hasEmitter()) {\n            const events = this.getOrCreateEmitter().eventNames();\n            await (0, promises_1.promiseMap)(events, removeByEvent);\n        }\n        return this;\n    }\n    deleteEmitterIfNothingRegistered(emitter) {\n        if (emitter.eventNames().length === 0) {\n            this.wire.eventAggregator.delete(__classPrivateFieldGet$e(this, _EmitterBase_emitterAccessor, \"f\"));\n        }\n    }\n}\nbase.EmitterBase = EmitterBase;\n_EmitterBase_emitterAccessor = new WeakMap();\nclass Reply {\n}\nbase.Reply = Reply;\n\nvar transportErrors = {};\n\nObject.defineProperty(transportErrors, \"__esModule\", { value: true });\ntransportErrors.RuntimeError = transportErrors.NotSupportedError = transportErrors.NotImplementedError = transportErrors.NoAckError = transportErrors.DuplicateCorrelationError = transportErrors.UnexpectedActionError = transportErrors.DisconnectedError = void 0;\nclass DisconnectedError extends Error {\n    constructor(readyState) {\n        super(`Expected websocket state OPEN but found ${readyState}`);\n        this.readyState = readyState;\n    }\n}\ntransportErrors.DisconnectedError = DisconnectedError;\nclass UnexpectedActionError extends Error {\n}\ntransportErrors.UnexpectedActionError = UnexpectedActionError;\nclass DuplicateCorrelationError extends Error {\n}\ntransportErrors.DuplicateCorrelationError = DuplicateCorrelationError;\nclass NoAckError extends Error {\n}\ntransportErrors.NoAckError = NoAckError;\nclass NotImplementedError extends Error {\n}\ntransportErrors.NotImplementedError = NotImplementedError;\nclass NotSupportedError extends Error {\n}\ntransportErrors.NotSupportedError = NotSupportedError;\nclass InternalError extends Error {\n    constructor(err) {\n        const { message, name, stack, ...rest } = err;\n        super(message);\n        this.name = name || 'Error';\n        this.stack = stack ?? this.toString();\n        Object.keys(rest).forEach(key => {\n            this[key] = rest[key];\n        });\n    }\n}\n// For documentation of the error methods being used see here: https://v8.dev/docs/stack-trace-api\nclass RuntimeError extends Error {\n    static getCallSite(callsToRemove = 0) {\n        const length = Error.stackTraceLimit;\n        const realCallsToRemove = callsToRemove + 1; // remove this call;\n        Error.stackTraceLimit = length + realCallsToRemove;\n        // eslint-disable-next-line no-underscore-dangle\n        const _prepareStackTrace = Error.prepareStackTrace;\n        // This will be called when we access the `stack` property\n        Error.prepareStackTrace = (_, stack) => stack;\n        // stack is optional in non chromium contexts\n        const stack = new Error().stack?.slice(realCallsToRemove) ?? [];\n        Error.prepareStackTrace = _prepareStackTrace;\n        Error.stackTraceLimit = length;\n        return stack;\n    }\n    static prepareStackTrace(err, callSites) {\n        if (typeof Error.prepareStackTrace === 'function') {\n            return Error.prepareStackTrace(err, callSites);\n        }\n        let string = \"\";\n        string += err.name || \"Error\";\n        string += `: ${err.message || \"\"}`;\n        for (const callSite of callSites) {\n            string += `\\n    at ${callSite.toString()}`;\n        }\n        return string;\n    }\n    ;\n    constructor(payload, callSites) {\n        const { reason, error } = payload;\n        super(reason);\n        this.name = 'RuntimeError';\n        if (error?.stack) {\n            this.cause = new InternalError(error);\n        }\n        if (callSites) {\n            this.stack = RuntimeError.prepareStackTrace(this, callSites);\n        }\n    }\n}\ntransportErrors.RuntimeError = RuntimeError;\n\nvar window$1 = {};\n\nvar Factory$8 = {};\n\nvar validate = {};\n\nObject.defineProperty(validate, \"__esModule\", { value: true });\nvalidate.validateIdentity = void 0;\nfunction validateIdentity(identity) {\n    let errorMsg;\n    if (typeof identity !== 'object' || typeof identity.uuid !== 'string') {\n        errorMsg = 'Not a valid identity object';\n    }\n    return errorMsg;\n}\nvalidate.validateIdentity = validateIdentity;\n\nvar Instance$7 = {};\n\nvar application = {};\n\nvar Factory$7 = {};\n\nvar Instance$6 = {};\n\nvar view = {};\n\nvar Factory$6 = {};\n\nvar warnings = {};\n\nObject.defineProperty(warnings, \"__esModule\", { value: true });\nwarnings.handleDeprecatedWarnings = void 0;\nconst handleDeprecatedWarnings = (options) => {\n    if (options.contentNavigation?.whitelist ||\n        options.contentNavigation?.blacklist ||\n        options.contentRedirect?.whitelist ||\n        options.contentRedirect?.blacklist) {\n        console.warn(`The properties 'whitelist' and 'blacklist' have been marked as deprecated and will be removed in a future version. Please use 'allowlist' and 'denylist'.`);\n    }\n};\nwarnings.handleDeprecatedWarnings = handleDeprecatedWarnings;\n\nvar hasRequiredFactory$3;\n\nfunction requireFactory$3 () {\n\tif (hasRequiredFactory$3) return Factory$6;\n\thasRequiredFactory$3 = 1;\n\tObject.defineProperty(Factory$6, \"__esModule\", { value: true });\n\tFactory$6.ViewModule = void 0;\n\tconst base_1 = base;\n\tconst validate_1 = validate;\n\tconst index_1 = requireView();\n\tconst warnings_1 = warnings;\n\t/**\n\t * Static namespace for OpenFin API methods that interact with the {@link View} class, available under `fin.View`.\n\t */\n\tclass ViewModule extends base_1.Base {\n\t    /**\n\t     * Creates a new View.\n\t     * @param options - View creation options\n\t     *\n\t     * @example\n\t     * ```js\n\t     * let view;\n\t     * async function createView() {\n\t     *     const me = await fin.Window.getCurrent();\n\t     *     return fin.View.create({\n\t     *         name: 'viewNameCreate',\n\t     *         target: me.identity,\n\t     *         bounds: {top: 10, left: 10, width: 200, height: 200}\n\t     *     });\n\t     * }\n\t     *\n\t     * createView()\n\t     *     .then((createdView) => {\n\t     *         view = createdView;\n\t     *         console.log('View created.', view);\n\t     *         view.navigate('https://google.com');\n\t     *         console.log('View navigated to given url.');\n\t     *     })\n\t     *     .catch(err => console.log(err));\n\t     * ```\n\t     * Note that created views needs to navigate somewhere for them to actually render a website.\n\t     * @experimental\n\t     */\n\t    async create(options) {\n\t        const { uuid } = this.wire.me;\n\t        if (!options.name || typeof options.name !== 'string') {\n\t            throw new Error('Please provide a name property as a string in order to create a View.');\n\t        }\n\t        (0, warnings_1.handleDeprecatedWarnings)(options);\n\t        if (this.wire.environment.childViews) {\n\t            await this.wire.environment.createChildContent({\n\t                entityType: 'view',\n\t                options: { ...options, uuid }\n\t            });\n\t        }\n\t        else {\n\t            await this.wire.sendAction('create-view', { ...options, uuid });\n\t        }\n\t        return this.wrapSync({ uuid, name: options.name });\n\t    }\n\t    /**\n\t     * Asynchronously returns an API handle for the given View identity.\n\t     *\n\t     * @remarks Wrapping a View identity that does not yet exist will *not* throw an error, and instead\n\t     * returns a stub object that cannot yet perform rendering tasks. This can be useful for plumbing eventing\n\t     * for a View throughout its entire lifecycle.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.View.wrap({ uuid: 'testViewUuid', name: 'testViewName' }))\n\t     *     .then(view => console.log('wrapped view', view))\n\t     *     .catch(err => console.log(err));\n\t     * ```\n\t     * @experimental\n\t     */\n\t    async wrap(identity) {\n\t        this.wire.sendAction('view-wrap').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const errorMsg = (0, validate_1.validateIdentity)(identity);\n\t        if (errorMsg) {\n\t            throw new Error(errorMsg);\n\t        }\n\t        return new index_1.View(this.wire, identity);\n\t    }\n\t    /**\n\t     * Synchronously returns an API handle for the given View identity.\n\t     *\n\t     * @remarks Wrapping a View identity that does not yet exist will *not* throw an error, and instead\n\t     * returns a stub object that cannot yet perform rendering tasks. This can be useful for plumbing eventing\n\t     * for a View throughout its entire lifecycle.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * const view = fin.View.wrapSync({ uuid: 'testView', name: 'testViewName' });\n\t     * await view.hide();\n\t     * ```\n\t     * @experimental\n\t     */\n\t    wrapSync(identity) {\n\t        this.wire.sendAction('view-wrap-sync').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const errorMsg = (0, validate_1.validateIdentity)(identity);\n\t        if (errorMsg) {\n\t            throw new Error(errorMsg);\n\t        }\n\t        return new index_1.View(this.wire, identity);\n\t    }\n\t    /**\n\t     * Asynchronously returns a View object that represents the current view\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.View.getCurrent()\n\t     *     .then(view => console.log('current view', view))\n\t     *     .catch(err => console.log(err));\n\t     *\n\t     * ```\n\t     * @experimental\n\t     */\n\t    getCurrent() {\n\t        this.wire.sendAction('view-get-current').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        if (!this.wire.me.isView) {\n\t            throw new Error('You are not in a View context');\n\t        }\n\t        const { uuid, name } = this.wire.me;\n\t        return this.wrap({ uuid, name });\n\t    }\n\t    /**\n\t     * Synchronously returns a View object that represents the current view\n\t     *\n\t     * @example\n\t     * ```js\n\t     * const view = fin.View.getCurrentSync();\n\t     * console.log(view);\n\t     *\n\t     * ```\n\t     * @experimental\n\t     */\n\t    getCurrentSync() {\n\t        this.wire.sendAction('view-get-current-sync').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        if (!this.wire.me.isView) {\n\t            throw new Error('You are not in a View context');\n\t        }\n\t        const { uuid, name } = this.wire.me;\n\t        return this.wrapSync({ uuid, name });\n\t    }\n\t}\n\tFactory$6.ViewModule = ViewModule;\n\treturn Factory$6;\n}\n\nvar Instance$5 = {};\n\nvar lazy = {};\n\nObject.defineProperty(lazy, \"__esModule\", { value: true });\nlazy.AsyncRetryableLazy = lazy.Lazy = void 0;\n/**\n * Handy class for managing asynchronous dependencies of classes.\n *\n * Will call the producer function once and only once when getValue is called,\n * returning the resultant value for every subsequent call.\n */\nclass Lazy {\n    // eslint-disable-next-line\n    constructor(producerFn) {\n        this.producerFn = producerFn;\n    }\n    /**\n     * Lazily get the value returned by the producer.\n     * @returns The value returned from the producer function\n     */\n    getValue() {\n        if (!this.value) {\n            this.value = this.producerFn();\n        }\n        return this.value;\n    }\n}\nlazy.Lazy = Lazy;\n/**\n * Handy class for managing asynchronous dependencies of classes.\n *\n * Will call asynchronous producer only after `getValue` is called.  If the\n * deferred code errors, we can try it again by re-calling `getValue` after\n * the promise rejects.\n */\nclass AsyncRetryableLazy {\n    // eslint-disable-next-line\n    constructor(producerFn) {\n        this.producerFn = producerFn;\n    }\n    /**\n     * Lazily get the value returned by the async producer.\n     *\n     * @returns The value returned from the producer function\n     */\n    async getValue() {\n        if (!this.promise) {\n            this.promise = this.producerFn().catch((e) => {\n                delete this.promise;\n                throw e;\n            });\n        }\n        return this.promise;\n    }\n}\nlazy.AsyncRetryableLazy = AsyncRetryableLazy;\n\nvar layoutEntities = {};\n\nvar apiExposer$1 = {};\n\nvar apiConsumer = {};\n\nObject.defineProperty(apiConsumer, \"__esModule\", { value: true });\napiConsumer.ApiConsumer = void 0;\n/**\n * Consumer for apis exposed with {@see ApiExposer}.\n *\n * A strategy that matches the strategy used to expose a target API must be provided.\n */\nclass ApiConsumer {\n    // eslint-disable-next-line\n    constructor(strategy) {\n        this.strategy = strategy;\n        /**\n         * Consumes an api exposed using a given transport strategy, and generates a client\n         * for easy, type safe consumption of that client.\n         * @param options Strategy specific consumption options.\n         * @returns An api client matching the given type.\n         */\n        this.consume = async (options) => {\n            const exposedProperties = await this.strategy.getExposedFunctions(options);\n            return exposedProperties.reduce((client, prop) => ({\n                ...client,\n                [prop.key]: this.strategy.createFunction(prop, options)\n            }), {});\n        };\n    }\n}\napiConsumer.ApiConsumer = ApiConsumer;\n\nvar apiExposer = {};\n\nvar decorators = {};\n\nObject.defineProperty(decorators, \"__esModule\", { value: true });\ndecorators.expose = decorators.getExposedProperties = void 0;\nconst exposedProperties = Symbol('exposedProperties');\nconst getExposedProperties = (target) => {\n    return target[exposedProperties] || target.prototype[exposedProperties] || [];\n};\ndecorators.getExposedProperties = getExposedProperties;\n/**\n * Indicates that a class member function can be exposed using {@link ApiExposer}.\n * @param options Options specific to the strategy used in {@link ApiExposer}\n */\n// Returns any as decorator typing is weird.\nconst expose = (options) => (target, key, descriptor) => {\n    target[exposedProperties] = target[exposedProperties] || [];\n    target[exposedProperties].push({ key, descriptor, options });\n};\ndecorators.expose = expose;\n\nObject.defineProperty(apiExposer, \"__esModule\", { value: true });\napiExposer.ApiExposer = void 0;\nconst decorators_1 = decorators;\n/**\n * Exposes api services on the transport of choice.\n */\nclass ApiExposer {\n    /**\n     * @param strategy The expose strategy to use to expose instances.\n     */\n    // eslint-disable-next-line\n    constructor(strategy) {\n        this.strategy = strategy;\n        /**\n         * Exposes an instance of a given api on\n         * @param instance Instance of a class which has been decorated to indicate which functions can be exposed.\n         * @param instanceOptions Transport strategy specific options to use when exposing.\n         */\n        this.exposeInstance = async (instance, instanceOptions) => {\n            const exposableProps = (0, decorators_1.getExposedProperties)(instance);\n            const exposedProps = await Promise.all(exposableProps.map(async ({ key, options }) => {\n                const customConsumptionOptions = await this.strategy.exposeFunction(instance[key].bind(instance), {\n                    key,\n                    options,\n                    meta: instanceOptions\n                });\n                return {\n                    key,\n                    options: customConsumptionOptions\n                };\n            }));\n            await this.strategy.exposeMeta(instanceOptions, exposedProps);\n        };\n    }\n    ;\n}\napiExposer.ApiExposer = ApiExposer;\n\nvar strategies = {};\n\nvar openfinChannels = {};\n\nvar channelsConsumer = {};\n\nObject.defineProperty(channelsConsumer, \"__esModule\", { value: true });\nchannelsConsumer.ChannelsConsumer = void 0;\nclass ChannelsConsumer {\n    // eslint-disable-next-line\n    constructor(channel) {\n        this.channel = channel;\n        this.getExposedFunctions = async (options) => {\n            const { id } = options;\n            const { props } = await this.channel.dispatch(`api-meta:${id}`);\n            return props;\n        };\n        this.createFunction = (prop) => (...args) => {\n            const { action } = prop.options;\n            return this.channel.dispatch(action, { args });\n        };\n    }\n    ;\n}\nchannelsConsumer.ChannelsConsumer = ChannelsConsumer;\n\nvar channelsExposer = {};\n\nObject.defineProperty(channelsExposer, \"__esModule\", { value: true });\nchannelsExposer.ChannelsExposer = void 0;\nclass ChannelsExposer {\n    // eslint-disable-next-line\n    constructor(channelProviderOrClient) {\n        this.channelProviderOrClient = channelProviderOrClient;\n        this.exposeFunction = async (target, config) => {\n            const { key, options, meta } = config;\n            const { id } = meta;\n            const action = `${id}.${options?.action || key}`;\n            await this.channelProviderOrClient.register(action, async ({ args }) => {\n                return target(...args);\n            });\n            return { action };\n        };\n        this.exposeMeta = async ({ id }, props) => {\n            const action = `api-meta:${id}`;\n            await this.channelProviderOrClient.register(action, () => ({ props }));\n        };\n    }\n}\nchannelsExposer.ChannelsExposer = ChannelsExposer;\n\n(function (exports) {\n\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t    }\n\t    Object.defineProperty(o, k2, desc);\n\t}) : (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    o[k2] = m[k];\n\t}));\n\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t};\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t__exportStar(channelsConsumer, exports);\n\t__exportStar(channelsExposer, exports); \n} (openfinChannels));\n\n(function (exports) {\n\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t    }\n\t    Object.defineProperty(o, k2, desc);\n\t}) : (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    o[k2] = m[k];\n\t}));\n\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t};\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t__exportStar(openfinChannels, exports); \n} (strategies));\n\n(function (exports) {\n\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t    }\n\t    Object.defineProperty(o, k2, desc);\n\t}) : (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    o[k2] = m[k];\n\t}));\n\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t};\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t__exportStar(apiConsumer, exports);\n\t__exportStar(apiExposer, exports);\n\t__exportStar(strategies, exports);\n\t__exportStar(decorators, exports); \n} (apiExposer$1));\n\nvar channelApiRelay = {};\n\nObject.defineProperty(channelApiRelay, \"__esModule\", { value: true });\nchannelApiRelay.createRelayedDispatch = channelApiRelay.relayChannelClientApi = void 0;\nconst EXPECTED_ERRORS = [\n    'no longer connected',\n    'RTCDataChannel closed unexpectedly',\n    'The client you are trying to dispatch from is disconnected from the target provider',\n];\n// Checks possible error messages that we want to trap, client error message can originate\n// from ChannelProvider::dispatch OR ClassicStrategy::closeEndpoint OR RTCEndPoint::dataChannel::onclose\nconst isDisconnectedError = (errorMsg) => {\n    return EXPECTED_ERRORS.some(e => errorMsg.includes(e));\n};\n/**\n * @internal\n * Create a channel relay for a given channel exposition, allowing a single provider to route\n * actions to the designated clients.\n *\n * Designed to be used in conjunction with @expose\n *\n * @param channelProvider The channel provider to relay the actions on.\n * @param config Determines which actions to relay. Please ensure action prefix matches the exposed api.\n */\nconst relayChannelClientApi = async (channelProvider, relayId) => {\n    channelProvider.register(`relay:${relayId}`, ({ action, target, payload }) => {\n        return channelProvider.dispatch(target, action, payload);\n    });\n    await Promise.resolve();\n};\nchannelApiRelay.relayChannelClientApi = relayChannelClientApi;\nconst createRelayedDispatch = (client, target, relayId, relayErrorMsg) => async (action, payload) => {\n    try {\n        return await client.dispatch(`relay:${relayId}`, {\n            action,\n            payload,\n            target\n        });\n    }\n    catch (e) {\n        if (isDisconnectedError(e.message) && relayErrorMsg) {\n            throw new Error(relayErrorMsg);\n        }\n        throw e;\n    }\n};\nchannelApiRelay.createRelayedDispatch = createRelayedDispatch;\n\nvar __classPrivateFieldSet$b = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar __classPrivateFieldGet$d = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar _LayoutNode_client, _TabStack_client, _ColumnOrRow_client;\nObject.defineProperty(layoutEntities, \"__esModule\", { value: true });\nlayoutEntities.ColumnOrRow = layoutEntities.TabStack = layoutEntities.LayoutNode = void 0;\nconst api_exposer_1 = apiExposer$1;\nconst channel_api_relay_1 = channelApiRelay;\n/*\n    This file includes LayoutNode, ColumnOrRow and TabStack classes, which are all closely\n    intertwined, and share members via parent abstract class LayoutNode. To prevent circular\n    refs, we define and export all the classes here.\n*/\n/**\n * @ignore\n * @internal\n * Supplies an ApiClient for {@link LayoutEntitiesController} and helper methods\n * for the entities {@link TabStack} AND {@link ColumnOrRow} to use.\n */\nclass LayoutNode {\n    /**\n     * @internal\n     * @ignore\n     */\n    constructor(client, entityId) {\n        /**\n         * @ignore\n         * @internal\n         * ApiClient for {@link LayoutEntitiesController}\n         */\n        _LayoutNode_client.set(this, void 0);\n        /**\n         * Checks if the TabStack or ColumnOrRow is the root content item\n         *\n         * @example\n         * ```js\n         * if (!fin.me.isView) {\n         *     throw new Error('Not running in a platform View.');\n         * }\n         *\n         * const stack = await fin.me.getCurrentStack();\n         * const isRoot = await stack.isRoot();\n         * // The TabStack is root: false\n         * console.log(`The TabStack is root: ${isRoot}`);\n         *\n         * // Retrieves the parent ColumnOrRow\n         * const parent = await stack.getParent();\n         * const parentIsRoot = await parent.isRoot();\n         * // The parent ColumnOrRow is root: true\n         * console.log(`The parent ColumnOrRow is root: ${parentIsRoot}`);\n         * ```\n         */\n        this.isRoot = () => __classPrivateFieldGet$d(this, _LayoutNode_client, \"f\").isRoot(this.entityId);\n        /**\n         * Checks if the TabStack or ColumnOrRow exists\n         *\n         * @example\n         * ```js\n         * if (!fin.me.isView) {\n         *     throw new Error('Not running in a platform View.');\n         * }\n         *\n         * const stack = await fin.me.getCurrentStack();\n         * // Retrieves the parent ColumnOrRow\n         * const columnOrRow = await stack.getParent();\n         * let exists = await stack.exists();\n         * // or\n         * let exists = await columnOrRow.exists();\n         * // The entity exists: true\n         * console.log(`The entity exists: ${exists}`);\n         * ```\n         */\n        this.exists = () => __classPrivateFieldGet$d(this, _LayoutNode_client, \"f\").exists(this.entityId);\n        /**\n         * Retrieves the parent of the TabStack or ColumnOrRow\n         *\n         * @example\n         * ```js\n         * if (!fin.me.isView) {\n         *     throw new Error('Not running in a platform View.');\n         * }\n         *\n         * const stack = await fin.me.getCurrentStack();\n         * // Retrieves the parent ColumnOrRow\n         * const columnOrRow = await stack.getParent();\n         *\n         * // undefined if entity is the root item\n         * let parent = await columnOrRow.getParent();\n         * // or\n         * let parent = await stack.getParent();\n         * ```\n         */\n        this.getParent = async () => {\n            const parent = await __classPrivateFieldGet$d(this, _LayoutNode_client, \"f\").getParent(this.entityId);\n            if (!parent) {\n                return undefined;\n            }\n            return LayoutNode.getEntity(parent, __classPrivateFieldGet$d(this, _LayoutNode_client, \"f\"));\n        };\n        /**\n         * Creates a new TabStack adjacent to the given TabStack or ColumnOrRow. Inputs can be new views to create, or existing views.\n         *\n         * Known Issue: If the number of views to add overflows the tab-container, the added views will be set as active\n         * during each render, and then placed at the front of the tab-stack, while the underlying order of tabs will remain unchanged.\n         * This means the views you pass to createAdjacentStack() may not render in the order given by the array.\n         * Until fixed, this problem can be avoided only if your window is wide enough to fit creating all the views in the tabstack.\n         *\n         * @param views The views that will populate the new TabStack.\n         * @param options Additional options that control new TabStack creation.\n         * @returns The newly-created TabStack.\n         *\n         * @example\n         * ```js\n         * if (!fin.me.isView) {\n         *     throw new Error('Not running in a platform View.');\n         * }\n         *\n         * const stack = await fin.me.getCurrentStack();\n         * const columnOrRow = await stack.getParent();\n         *\n         * // Create view references by supplying a 'name' and 'url'\n         * const views = [\n         *     // if 'name' is undefined, one will be generated\n         *     // if 'url' is undefined, it will default the view URL to 'about:blank'\n         *     { name: 'google-view', url: 'http://google.com/'},\n         *     { name: 'of-developers-view', url: 'http://developers.openfin.co/'},\n         * ];\n         *\n         * // Create a view beforehand to be included in the new tab stack\n         * const outsideView = await fin.View.create({\n         *     name: 'outside-bloomberg-view',\n         *     url: 'https://bloomberg.com/',\n         *     target: fin.me.identity,\n         * });\n         *\n         * // Views to add can be identities, or the reference views mentioned above\n         * const viewsToAdd = [outsideView.identity, ...views];\n         *\n         * // Possible position inputs: 'right' | 'left' | 'top' | 'bottom'\n         * let stackFrom = await columnOrRow.createAdjacentStack(viewsToAdd, { position: 'right' });\n         * // Or\n         * let newStack = await stack.createAdjacentStack(viewsToAdd, { position: 'right' });\n         * console.log(`A new TabStack created to the right has ${newStack.length} views in it`);\n         *\n         * ```\n         * @experimental\n         */\n        this.createAdjacentStack = async (views, options) => {\n            const entityId = await __classPrivateFieldGet$d(this, _LayoutNode_client, \"f\").createAdjacentStack(this.entityId, views, options);\n            return LayoutNode.getEntity({ entityId, type: 'stack' }, __classPrivateFieldGet$d(this, _LayoutNode_client, \"f\"));\n        };\n        /**\n         * Retrieves the adjacent TabStacks of the given TabStack or ColumnOrRow.\n         *\n         * @param edge Edge whose adjacent TabStacks will be returned.\n         *\n         * @example\n         * ```js\n         * if (!fin.me.isView) {\n         *     throw new Error('Not running in a platform View.');\n         * }\n         *\n         * const stack = await fin.me.getCurrentStack();\n         * const columnOrRow = await stack.getParent();\n         * // Possible position inputs: 'right' | 'left' | 'top' | 'bottom'\n         * let rightStacks = await columnOrRow.getAdjacentStacks('right');\n         * let leftStacks = await columnOrRow.getAdjacentStacks('left');\n         * // or\n         * let rightStacks = await stack.getAdjacentStacks('right');\n         * let leftStacks = await stack.getAdjacentStacks('left');\n         *\n         * console.log(`The entity has ${rightStacks.length} stacks to the right, and ${leftStacks.length} stacks to the left`);\n         *\n         * ```\n         * @experimental\n         */\n        this.getAdjacentStacks = async (edge) => {\n            const adjacentStacks = await __classPrivateFieldGet$d(this, _LayoutNode_client, \"f\").getAdjacentStacks({\n                targetId: this.entityId,\n                edge\n            });\n            return adjacentStacks.map((stack) => LayoutNode.getEntity({\n                type: 'stack',\n                entityId: stack.entityId\n            }, __classPrivateFieldGet$d(this, _LayoutNode_client, \"f\")));\n        };\n        __classPrivateFieldSet$b(this, _LayoutNode_client, client, \"f\");\n        this.entityId = entityId;\n    }\n}\nlayoutEntities.LayoutNode = LayoutNode;\n_LayoutNode_client = new WeakMap();\n/**\n * @ignore\n * @internal\n * Encapsulates Api consumption of {@link LayoutEntitiesClient} with a relayed dispatch\n * @param client\n * @param controllerId\n * @param identity\n * @returns a new instance of {@link LayoutEntitiesClient} with bound to the controllerId\n */\nLayoutNode.newLayoutEntitiesClient = async (client, controllerId, identity) => {\n    const dispatch = (0, channel_api_relay_1.createRelayedDispatch)(client, identity, 'layout-relay', 'You are trying to interact with a layout component on a window that does not exist or has been destroyed.');\n    const consumer = new api_exposer_1.ApiConsumer(new api_exposer_1.ChannelsConsumer({ dispatch }));\n    return consumer.consume({ id: controllerId });\n};\nLayoutNode.getEntity = (definition, client) => {\n    const { entityId, type } = definition;\n    switch (type) {\n        case 'column':\n        case 'row':\n            return new ColumnOrRow(client, entityId, type);\n        case 'stack':\n            return new TabStack(client, entityId);\n        default:\n            throw new Error(`Unrecognised Layout Entity encountered ('${JSON.stringify(definition)})`);\n    }\n};\n/**\n * A TabStack is used to manage the state of a stack of tabs within an OpenFin Layout.\n */\nclass TabStack extends LayoutNode {\n    /** @internal */\n    constructor(client, entityId) {\n        super(client, entityId);\n        /**\n         * @internal\n         * ApiClient for {@link LayoutEntitiesController}\n         */\n        _TabStack_client.set(this, void 0);\n        /**\n         * Type of the content item. Always stack, but useful for distinguishing between a {@link TabStack} and {@link ColumnOrRow}.\n         */\n        this.type = 'stack';\n        /**\n         * Retrieves a list of all views belonging to this {@link TabStack}.\n         *\n         * Known Issue: If adding a view overflows the tab-container width, the added view will be set as active\n         * and rendered at the front of the tab-stack, while the underlying order of tabs will remain unchanged.\n         * If that happens and then getViews() is called, it will return the identities in a different order than\n         * than the currently rendered tab order.\n         *\n         *\n         * @throws If the {@link TabStack} has been destroyed.\n         * @example\n         * ```js\n         * if (!fin.me.isView) {\n         *     throw new Error('Not running in a platform View.');\n         * }\n         *\n         * const stack = await fin.me.getCurrentStack();\n         * // Alternatively, you can wrap any view and get the stack from there\n         * // const viewFromSomewhere = fin.View.wrapSync(someView.identity);\n         * // const stack = await viewFromSomewhere.getCurrentStack();\n         * const views = await stack.getViews();\n         * console.log(`Stack contains ${views.length} view(s)`);\n         * ```\n         * @experimental\n         */\n        this.getViews = () => __classPrivateFieldGet$d(this, _TabStack_client, \"f\").getStackViews(this.entityId);\n        /**\n         * Adds or creates a view in this {@link TabStack}.\n         *\n         * @remarks Known Issue: If adding a view overflows the tab-container, the added view will be set as active\n         * and rendered at the front of the tab-stack, while the underlying order of tabs will remain unchanged.\n         *\n         * @param view The identity of an existing view to add, or options to create a view.\n         * @param options Optional view options: index number used to insert the view into the stack at that index. Defaults to 0 (front of the stack)\n         * @returns Resolves with the {@link OpenFin.Identity identity} of the added view.\n         * @throws If the view does not exist or fails to create.\n         * @throws If the {@link TabStack} has been destroyed.\n         * @example\n         * ```js\n         * if (!fin.me.isView) {\n         *     throw new Error('Not running in a platform View.');\n         * }\n         *\n         * const stack = await fin.me.getCurrentStack();\n         * // Alternatively, you can wrap any view and get the stack from there\n         * // const viewFromSomewhere = fin.View.wrapSync(someView.identity);\n         * // const stack = await viewFromSomewhere.getCurrentStack();\n         * const googleViewIdentity = await stack.addView({ name: 'google-view', url: 'http://google.com/' });\n         * console.log('Identity of the google view just added', { googleViewIdentity });\n         * // pass in { index: number } to set the index in the stack. Here 1 means, end of the stack (defaults to 0)\n         * const appleViewIdentity = await stack.addView({ name: 'apple-view', url: 'http://apple.com/' }, { index: 1 });\n         * console.log('Identity of the apple view just added', { appleViewIdentity });\n         * ```\n         * @experimental\n         */\n        this.addView = async (view, options = { index: 0 }) => __classPrivateFieldGet$d(this, _TabStack_client, \"f\").addViewToStack(this.entityId, view, options);\n        /**\n         * Removes a view from this {@link TabStack}.\n         *\n         * @remarks Throws an exception if the view identity does not exist or was already destroyed.\n         *\n         * @param view - Identity of the view to remove.\n         * @throws If the view does not exist or does not belong to the stack.\n         * @throws If the {@link TabStack} has been destroyed.\n         *\n         * @example\n         * ```js\n         * if (!fin.me.isView) {\n         *     throw new Error('Not running in a platform View.');\n         * }\n         *\n         * const stack = await fin.me.getCurrentStack();\n         * const googleViewIdentity = await stack.addView({ name: 'google-view', url: 'http://google.com/' });\n         *\n         * await stack.removeView(googleViewIdentity);\n         *\n         * try {\n         *     await stack.removeView(googleViewIdentity);\n         * } catch (error) {\n         *     // Tried to remove a view ('google-view') which does not belong to the stack.\n         *     console.log(error);\n         * }\n         * ```\n         */\n        this.removeView = async (view) => {\n            await __classPrivateFieldGet$d(this, _TabStack_client, \"f\").removeViewFromStack(this.entityId, view);\n        };\n        /**\n         * Sets the active view of the {@link TabStack} without focusing it.\n         * @param view - Identity of the view to activate.\n         * @returns Promise which resolves with void once the view has been activated.\n         * @throws If the {@link TabStack} has been destroyed.\n         * @throws If the view does not exist.\n         * @example\n         * Change the active tab of a known View's TabStack:\n         * ```js\n         * const targetView = fin.View.wrapSync({ uuid: 'uuid', name: 'view-name' });\n         * const stack = await targetView.getCurrentStack();\n         * await stack.setActiveView(targetView.identity);\n         * ```\n         *\n         * Set the current View as active within its TabStack:\n         * ```js\n         * const stack = await fin.me.getCurrentStack();\n         * await stack.setActiveView(fin.me.identity);\n         * ```\n         * @experimental\n         */\n        this.setActiveView = async (view) => {\n            await __classPrivateFieldGet$d(this, _TabStack_client, \"f\").setStackActiveView(this.entityId, view);\n        };\n        __classPrivateFieldSet$b(this, _TabStack_client, client, \"f\");\n    }\n}\nlayoutEntities.TabStack = TabStack;\n_TabStack_client = new WeakMap();\n/**\n * A ColumnOrRow is used to manage the state of Column and Rows within an OpenFin Layout.\n */\nclass ColumnOrRow extends LayoutNode {\n    /**\n     * @internal\n     */\n    constructor(client, entityId, type) {\n        super(client, entityId);\n        /**\n         * @ignore\n         * @internal\n         * ApiClient for {@link LayoutEntitiesController}\n         */\n        _ColumnOrRow_client.set(this, void 0);\n        /**\n         * Retrieves the content array of the ColumnOrRow\n         *\n         * @example\n         * ```js\n         * if (!fin.me.isView) {\n         *     throw new Error('Not running in a platform View.');\n         * }\n         *\n         * const stack = await fin.me.getCurrentStack();\n         * // Retrieves the parent ColumnOrRow\n         * const columnOrRow = await stack.getParent();\n         *\n         * // returns [TabStack]\n         * const contentArray = await columnOrRow.getContent();\n         * console.log(`The ColumnOrRow has ${contentArray.length} item(s)`);\n         * ```\n         */\n        this.getContent = async () => {\n            const contentItemEntities = await __classPrivateFieldGet$d(this, _ColumnOrRow_client, \"f\").getContent(this.entityId);\n            return contentItemEntities.map((entity) => LayoutNode.getEntity(entity, __classPrivateFieldGet$d(this, _ColumnOrRow_client, \"f\")));\n        };\n        __classPrivateFieldSet$b(this, _ColumnOrRow_client, client, \"f\");\n        this.type = type;\n    }\n}\nlayoutEntities.ColumnOrRow = ColumnOrRow;\n_ColumnOrRow_client = new WeakMap();\n\nvar layout_constants = {};\n\nObject.defineProperty(layout_constants, \"__esModule\", { value: true });\nlayout_constants.DEFAULT_LAYOUT_KEY = layout_constants.LAYOUT_CONTROLLER_ID = void 0;\nlayout_constants.LAYOUT_CONTROLLER_ID = 'layout-entities';\n// TODO: eventually export this somehow\nlayout_constants.DEFAULT_LAYOUT_KEY = '__default__';\n\nvar main = {};\n\nObject.defineProperty(main, \"__esModule\", { value: true });\nmain.WebContents = void 0;\nconst base_1$j = base;\nclass WebContents extends base_1$j.EmitterBase {\n    /**\n     * @param identity The identity of the {@link OpenFin.WebContentsEvents WebContents}.\n     * @param entityType The type of the {@link OpenFin.WebContentsEvents WebContents}.\n     */\n    constructor(wire, identity, entityType) {\n        super(wire, entityType, identity.uuid, identity.name);\n        this.identity = identity;\n        this.entityType = entityType;\n    }\n    /**\n     * Gets a base64 encoded image of all or part of the WebContents.\n     * @param options Options for the capturePage call.\n     *\n     * @example\n     *\n     * View:\n     * ```js\n     * const view = fin.View.getCurrentSync();\n     *\n     * // PNG image of a full visible View\n     * console.log(await view.capturePage());\n     *\n     * // Low-quality JPEG image of a defined visible area of the view\n     * const options = {\n     *     area: {\n     *         height: 100,\n     *         width: 100,\n     *         x: 10,\n     *         y: 10,\n     *     },\n     *     format: 'jpg',\n     *     quality: 20\n     * }\n     * console.log(await view.capturePage(options));\n     * ```\n     *\n     * Window:\n     * ```js\n     * const wnd = await fin.Window.getCurrent();\n     *\n     * // PNG image of a full visible window\n     * console.log(await wnd.capturePage());\n     *\n     * // Low-quality JPEG image of a defined visible area of the window\n     * const options = {\n     *     area: {\n     *         height: 100,\n     *         width: 100,\n     *         x: 10,\n     *         y: 10,\n     *     },\n     *     format: 'jpg',\n     *     quality: 20\n     * }\n     * console.log(await wnd.capturePage(options));\n     * ```\n     *\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    capturePage(options) {\n        return this.wire.sendAction('capture-page', { options, ...this.identity }).then(({ payload }) => payload.data);\n    }\n    /**\n     * Executes Javascript on the WebContents, restricted to contents you own or contents owned by\n     * applications you have created.\n     * @param code JavaScript code to be executed on the view.\n     *\n     * @example\n     * View:\n     * ```js\n     * async function executeJavaScript(code) {\n     *     const view = await fin.View.wrap({uuid: 'uuid', name: 'view name'});\n     *     return await view.executeJavaScript(code);\n     * }\n     *\n     * executeJavaScript(`console.log('Hello, Openfin')`).then(() => console.log('Javascript excuted')).catch(err => console.log(err));\n     * ```\n     *\n     * Window:\n     * ```js\n     * async function executeJavaScript(code) {\n     *     const app = await fin.Application.start({\n     *         name: 'myApp',\n     *         uuid: 'app-1',\n     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.executeJavaScript.html',\n     *         autoShow: true\n     *     });\n     *     const win = await app.getWindow();\n     *     return await win.executeJavaScript(code);\n     * }\n     *\n     * executeJavaScript(`console.log('Hello, Openfin')`).then(() => console.log('Javascript excuted')).catch(err => console.log(err));\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    executeJavaScript(code) {\n        return this.wire\n            .sendAction('execute-javascript-in-window', { ...this.identity, code })\n            .then(({ payload }) => payload.data);\n    }\n    /**\n     * Returns the zoom level of the WebContents.\n     *\n     * @example\n     * View:\n     * ```js\n     * async function getZoomLevel() {\n     *     const view = await fin.View.getCurrent();\n     *     return await view.getZoomLevel();\n     * }\n     *\n     * getZoomLevel().then(zoomLevel => console.log(zoomLevel)).catch(err => console.log(err));\n     * ```\n     *\n     * Window:\n     * ```js\n     * async function createWin() {\n     *     const app = await fin.Application.start({\n     *         name: 'myApp',\n     *         uuid: 'app-1',\n     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getZoomLevel.html',\n     *         autoShow: true\n     *     });\n     *     return await app.getWindow();\n     * }\n     *\n     * async function getZoomLevel() {\n     *     const win = await createWin();\n     *     return await win.getZoomLevel();\n     * }\n     *\n     * getZoomLevel().then(zoomLevel => console.log(zoomLevel)).catch(err => console.log(err));\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    getZoomLevel() {\n        return this.wire.sendAction('get-zoom-level', this.identity).then(({ payload }) => payload.data);\n    }\n    /**\n     * Sets the zoom level of the WebContents.\n     * @param level The zoom level\n     *\n     * @example\n     * View:\n     * ```js\n     * async function setZoomLevel(number) {\n     *     const view = await fin.View.getCurrent();\n     *     return await view.setZoomLevel(number);\n     * }\n     *\n     * setZoomLevel(4).then(() => console.log('Setting a  zoom level')).catch(err => console.log(err));\n     * ```\n     *\n     * Window:\n     * ```js\n     * async function createWin() {\n     *     const app = await fin.Application.start({\n     *         name: 'myApp',\n     *         uuid: 'app-1',\n     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.setZoomLevel.html',\n     *         autoShow: true\n     *     });\n     *     return await app.getWindow();\n     * }\n     *\n     * async function setZoomLevel(number) {\n     *     const win = await createWin();\n     *     return await win.setZoomLevel(number);\n     * }\n     *\n     * setZoomLevel(4).then(() => console.log('Setting a  zoom level')).catch(err => console.log(err));\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    setZoomLevel(level) {\n        return this.wire.sendAction('set-zoom-level', { ...this.identity, level }).then(() => undefined);\n    }\n    /**\n     * Navigates the WebContents to a specified URL.\n     *\n     * Note: The url must contain the protocol prefix such as http:// or https://.\n     * @param url - The URL to navigate the WebContents to.\n     *\n     * @example\n     * View:\n     * ```js\n     * async function createView() {\n     *     const me = await fin.Window.getCurrent();\n     *     return fin.View.create({\n     *         name: 'viewName',\n     *         target: me.identity,\n     *         bounds: {top: 10, left: 10, width: 200, height: 200}\n     *     });\n     * }\n     *\n     * createView()\n     *     .then(view => view.navigate('https://example.com'))\n     *     .then(() => console.log('navigation complete'))\n     *     .catch(err => console.log(err));\n     * ```\n     *\n     * Window:\n     * ```js\n     * async function navigate() {\n     *     const win = await fin.Window.getCurrent();\n     *     return await win.navigate('https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.navigate.html');\n     * }\n     * navigate().then(() => console.log('Navigate to tutorial')).catch(err => console.log(err));\n     * ```\n     * @experimental\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    navigate(url) {\n        return this.wire.sendAction('navigate-window', { ...this.identity, url }).then(() => undefined);\n    }\n    /**\n     * Navigates the WebContents back one page.\n     *\n     * @example\n     * View:\n     * ```js\n     * async function navigateBack() {\n     *     const view = await fin.View.wrap({ name: 'testapp-view', uuid: 'testapp' });\n     *     await view.navigate('https://www.google.com');\n     *     return await view.navigateBack();\n     * }\n     * navigateBack().then(() => console.log('Navigated back')).catch(err => console.log(err));\n     * ```\n     *\n     * Window:\n     * ```js\n     * async function navigateBack() {\n     *     const win = await fin.Window.wrap({ name: 'testapp', uuid: 'testapp' });\n     *     await win.navigate('https://www.google.com');\n     *     return await win.navigateBack();\n     * }\n     * navigateBack().then(() => console.log('Navigated back')).catch(err => console.log(err));\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    navigateBack() {\n        return this.wire.sendAction('navigate-window-back', { ...this.identity }).then(() => undefined);\n    }\n    /**\n     * Navigates the WebContents forward one page.\n     *\n     * @example\n     * View:\n     * ```js\n     * async function navigateForward() {\n     *     const view = await fin.View.getCurrent();\n     *     await view.navigate('https://www.google.com');\n     *     await view.navigateBack();\n     *     return await view.navigateForward();\n     * }\n     * navigateForward().then(() => console.log('Navigated forward')).catch(err => console.log(err));\n     * ```\n     *\n     * Window:\n     * ```js\n     * async function navigateForward() {\n     *     const win = await fin.Window.getCurrent();\n     *     await win.navigate('https://www.google.com');\n     *     await win.navigateBack();\n     *     return await win.navigateForward();\n     * }\n     * navigateForward().then(() => console.log('Navigated forward')).catch(err => console.log(err));\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    async navigateForward() {\n        await this.wire.sendAction('navigate-window-forward', { ...this.identity });\n    }\n    /**\n     * Stops any current navigation the WebContents is performing.\n     *\n     * @example\n     * View:\n     * ```js\n     * async function stopNavigation() {\n     *     const view = await fin.View.wrap({ name: 'testapp-view', uuid: 'testapp' });\n     *     await view.navigate('https://www.google.com');\n     *     return await view.stopNavigation();\n     * }\n     * stopNavigation().then(() => console.log('you shall not navigate')).catch(err => console.log(err));\n     * ```\n     *\n     * Window:\n     * ```js\n     * async function stopNavigation() {\n     *     const win = await fin.Window.wrap({ name: 'testapp', uuid: 'testapp' });\n     *     await win.navigate('https://www.google.com');\n     *     return await win.stopNavigation();\n     * }\n     * stopNavigation().then(() => console.log('you shall not navigate')).catch(err => console.log(err));\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    stopNavigation() {\n        return this.wire.sendAction('stop-window-navigation', { ...this.identity }).then(() => undefined);\n    }\n    /**\n     * Reloads the WebContents\n     *\n     * @example\n     * View:\n     * ```js\n     * async function reload() {\n     * \tconst view = await fin.View.getCurrent();\n     *     return await view.reload();\n     * }\n     *\n     * reload().then(() => {\n     * \t\tconsole.log('Reloaded view')\n     * }).catch(err => console.log(err));\n     * ```\n     *\n     * Window:\n     * ```js\n     * async function reloadWindow() {\n     * \t\tconst app = await fin.Application.start({\n     * \t\t\t\tname: 'myApp',\n     * \t\t\t\tuuid: 'app-1',\n     * \t\t\t\turl: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.reload.html',\n     * \t\t\t\tautoShow: true\n     * \t\t});\n     * \t\tconst win = await app.getWindow();\n     *     return await win.reload();\n     * }\n     *\n     * reloadWindow().then(() => {\n     * \t\tconsole.log('Reloaded window')\n     * }).catch(err => console.log(err));\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    reload(ignoreCache = false) {\n        return this.wire\n            .sendAction('reload-window', {\n            ignoreCache,\n            ...this.identity\n        })\n            .then(() => undefined);\n    }\n    /**\n     * Prints the WebContents.\n     * @param options Printer Options\n     *\n     * Note: When `silent` is set to `true`, the API will pick the system's default printer if deviceName\n     * is empty and the default settings for printing.\n     *\n     * Use the CSS style `page-break-before: always;` to force print to a new page.\n     *\n     * @example\n     * ```js\n     * const view = fin.View.getCurrentSync();\n     *\n     * view.print({ silent: false, deviceName: 'system-printer-name' }).then(() => {\n     *     console.log('print call has been sent to the system');\n     * });\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    print(options = {}) {\n        return this.wire.sendAction('print', { ...this.identity, options }).then(() => undefined);\n    }\n    /**\n     * Find and highlight text on a page.\n     * @param searchTerm Term to find in page\n     * @param options Search options\n     *\n     * Note: By default, each subsequent call will highlight the next text that matches the search term.\n     *\n     * Returns a promise with the results for the request. By subscribing to the\n     * found-in-page event, you can get the results of this call as well.\n     *\n     * @example\n     * View:\n     * ```js\n     * const view = fin.View.getCurrentSync();\n     *\n     * //By subscribing to the 'found in page' event we can get the results of each findInPage call made.\n     * view.addListener('found-in-page', (event) => {\n     *     console.log(event);\n     * });\n     *\n     * // The promise also returns the results for the request\n     * view.findInPage('a').then((result) => {\n     *     console.log(result)\n     * });\n     * ```\n     *\n     * Window:\n     * ```js\n     * const win = fin.Window.getCurrentSync();\n     *\n     * //By subscribing to the 'found in page' event we can get the results of each findInPage call made.\n     * win.addListener('found-in-page', (event) => {\n     *     console.log(event);\n     * });\n     *\n     * // The promise also returns the results for the request\n     * win.findInPage('a').then((result) => {\n     *     console.log(result)\n     * });\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    findInPage(searchTerm, options) {\n        return this.wire\n            .sendAction('find-in-page', { ...this.identity, searchTerm, options })\n            .then(({ payload }) => payload.data);\n    }\n    /**\n     * Stop a {@link View#findInPage findInPage} call by specifying any of these actions:\n     *\n     * * clearSelection - Clear the selection.\n     * * keepSelection - Translate the selection into a normal selection.\n     * * activateSelection - Focus and click the selection node.\n     *\n     * @example\n     * View:\n     * ```js\n     * const view = fin.View.getCurrentSync();\n     *\n     * view.addListener('found-in-page', (event) => {\n     *     setTimeout(() => {\n     *         view.stopFindInPage('clearSelection');\n     *     }, 5000);\n     * });\n     *\n     * view.findInPage('a').then(results => {\n     *     console.log(results);\n     * });\n     * ```\n     *\n     * Window:\n     * ```js\n     * const win = fin.Window.getCurrentSync();\n     *\n     * win.addListener('found-in-page', (event) => {\n     *     setTimeout(() => {\n     *         win.stopFindInPage('clearSelection');\n     *     }, 5000);\n     * });\n     *\n     * win.findInPage('a').then(results => {\n     *     console.log(results);\n     * });\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    stopFindInPage(action) {\n        return this.wire.sendAction('stop-find-in-page', { ...this.identity, action }).then(() => undefined);\n    }\n    /**\n     * Returns an array with all system printers\n     * @deprecated use System.getPrinters instead\n     *\n     * @example\n     * View:\n     * ```js\n     * const view = fin.View.getCurrentSync();\n     *\n     * view.getPrinters()\n     *     .then((printers) => {\n     *         printers.forEach((printer) => {\n     *             if (printer.isDefault) {\n     *                 console.log(printer);\n     *             }\n     *         });\n     *     })\n     *     .catch((err) => {\n     *         console.log(err);\n     *     });\n     * ```\n     *\n     * Window:\n     * ```js\n     * const win = fin.Window.getCurrentSync();\n     *\n     * win.getPrinters()\n     *     .then((printers) => {\n     *         printers.forEach((printer) => {\n     *             if (printer.isDefault) {\n     *                 console.log(printer);\n     *             }\n     *         });\n     *     })\n     *     .catch((err) => {\n     *         console.log(err);\n     *     });\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    getPrinters() {\n        return this.wire.sendAction('get-printers', { ...this.identity }).then(({ payload }) => payload.data);\n    }\n    /**\n     * Gives focus to the WebContents.\n     *\n     * @example\n     * ```js\n     * async function focusWindow() {\n     *     const app = await fin.Application.start({\n     *         name: 'myApp',\n     *         uuid: 'app-1',\n     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.focus.html',\n     *         autoShow: true\n     *     });\n     *     const win = await app.getWindow();\n     *     return await win.focus();\n     * }\n     *\n     * focusWindow().then(() => console.log('Window focused')).catch(err => console.log(err));\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    async focus({ emitSynthFocused } = { emitSynthFocused: true }) {\n        await this.wire.sendAction('focus-window', { emitSynthFocused, ...this.identity });\n    }\n    /**\n     * Shows the Chromium Developer Tools\n     *\n     * @example\n     * View:\n     * ```js\n     * async function showDeveloperTools() {\n     *     const view = await fin.View.getCurrent();\n     *     return view.showDeveloperTools();\n     * }\n     *\n     * showDevelopertools()\n     * .then(() => console.log('Showing dev tools'))\n     * .catch(err => console.error(err));\n     * ```\n     *\n     * Window:\n     * ```js\n     * async function showDeveloperTools() {\n     *     const win = await fin.Window.getCurrent();\n     *     return win.showDeveloperTools();\n     * }\n     *\n     * showDevelopertools()\n     * .then(() => console.log('Showing dev tools'))\n     * .catch(err => console.error(err));\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    async showDeveloperTools() {\n        // Note this hits the system action map in core state for legacy reasons.\n        await this.wire.sendAction('show-developer-tools', this.identity);\n    }\n    /**\n     * Retrieves the process information associated with a WebContents.\n     *\n     * Note: This includes any iframes associated with the WebContents\n     *\n     * @example\n     * View:\n     * ```js\n     *     const view = await fin.View.getCurrent();\n     *     const processInfo = await view.getProcessInfo();\n     * ```\n     *\n     * Window:\n     * ```js\n     *     const win = await fin.Window.getCurrent();\n     *     const processInfo = await win.getProcessInfo();\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    async getProcessInfo() {\n        const { payload: { data } } = await this.wire.sendAction('get-process-info', this.identity);\n        return data;\n    }\n    /**\n     * Retrieves information on all Shared Workers.\n     *\n     * @example\n     * View:\n     * ```js\n     *     const view = await fin.View.create({\n     *         name: 'viewName',\n     *         target: fin.me.identity,\n     *         bounds: {top: 10, left: 10, width: 200, height: 200}\n     *     });\n     *\n     *     await view.navigate('https://mdn.github.io/dom-examples/web-workers/simple-shared-worker/');\n     *\n     *     const sharedWorkers = await view.getSharedWorkers();\n     * ```\n     *\n     * Window:\n     * ```js\n     *     const winOption = {\n     *         name:'child',\n     *         defaultWidth: 300,\n     *         defaultHeight: 300,\n     *         url: 'https://mdn.github.io/dom-examples/web-workers/simple-shared-worker/',\n     *         frame: true,\n     *         autoShow: true\n     *     };\n     *     const win = await fin.Window.create(winOption);\n     *     const sharedWorkers = await win.getSharedWorkers();\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    async getSharedWorkers() {\n        return this.wire.sendAction('get-shared-workers', this.identity).then(({ payload }) => payload.data);\n    }\n    /**\n     * Opens the developer tools for the shared worker context.\n     *\n     * @example\n     * View:\n     * ```js\n     *     const view = await fin.View.create({\n     *         name: 'viewName',\n     *         target: fin.me.identity,\n     *         bounds: {top: 10, left: 10, width: 200, height: 200}\n     *     });\n     *\n     *     await view.navigate('https://mdn.github.io/dom-examples/web-workers/simple-shared-worker/');\n     *\n     *     await view.inspectSharedWorker();\n     * ```\n     *\n     * Example:\n     * ```js\n     *     const winOption = {\n     *         name:'child',\n     *         defaultWidth: 300,\n     *         defaultHeight: 300,\n     *         url: 'https://mdn.github.io/dom-examples/web-workers/simple-shared-worker/',\n     *         frame: true,\n     *         autoShow: true\n     *     };\n     *     const win = await fin.Window.create(winOption);\n     *     await win.inspectSharedWorker();\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    async inspectSharedWorker() {\n        await this.wire.sendAction('inspect-shared-worker', { ...this.identity });\n    }\n    /**\n     * Inspects the shared worker based on its ID.\n     * @param workerId - The id of the shared worker.\n     *\n     * @example\n     * View:\n     * ```js\n     *     const view = await fin.View.create({\n     *         name: 'viewName',\n     *         target: fin.me.identity,\n     *         bounds: {top: 10, left: 10, width: 200, height: 200}\n     *     });\n     *\n     *     await view.navigate('https://mdn.github.io/dom-examples/web-workers/simple-shared-worker/');\n     *\n     *     const sharedWorkers = await view.getSharedWorkers();\n     *     await view.inspectSharedWorkerById(sharedWorkers[0].id);\n     * ```\n     *\n     * Window:\n     * ```js\n     *     const winOption = {\n     *         name:'child',\n     *         defaultWidth: 300,\n     *         defaultHeight: 300,\n     *         url: 'https://mdn.github.io/dom-examples/web-workers/simple-shared-worker/',\n     *         frame: true,\n     *         autoShow: true\n     *     };\n     *     const win = await fin.Window.create(winOption);\n     *     const sharedWorkers = await win.getSharedWorkers();\n     *     await win.inspectSharedWorkerById(sharedWorkers[0].id);\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    async inspectSharedWorkerById(workerId) {\n        await this.wire.sendAction('inspect-shared-worker-by-id', { ...this.identity, workerId });\n    }\n    /**\n     * Opens the developer tools for the service worker context.\n     *\n     * @example\n     * View:\n     * ```js\n     *     const view = await fin.View.create({\n     *         name: 'viewName',\n     *         target: fin.me.identity,\n     *         bounds: {top: 10, left: 10, width: 200, height: 200}\n     *     });\n     *\n     *     await view.navigate('http://googlechrome.github.io/samples/service-worker/basic/index.html');\n     *\n     *     await view.inspectServiceWorker();\n     * ```\n     *\n     * Window:\n     * ```js\n     *     const winOption = {\n     *         name:'child',\n     *         defaultWidth: 300,\n     *         defaultHeight: 300,\n     *         url: 'http://googlechrome.github.io/samples/service-worker/basic/index.html',\n     *         frame: true,\n     *         autoShow: true\n     *     };\n     *     const win = await fin.Window.create(winOption);\n     *     await win.inspectServiceWorker();\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    async inspectServiceWorker() {\n        await this.wire.sendAction('inspect-service-worker', { ...this.identity });\n    }\n    /**\n     * Shows a popup window.\n     *\n     * Note: If this WebContents is a view and its attached window has a popup open, this will close it.\n     *\n     * Shows a popup window. Including a `name` in `options` will attempt to show an existing window as a popup, if\n     * that window doesn't exist or no `name` is included a window will be created. If the caller view or the caller\n     * view's parent window currently has a popup window open, calling `showPopupWindow` again will dismiss the currently\n     * open popup window before showing the new popup window. Also, if the caller view is destroyed or detached, the popup\n     * will be dismissed.\n     *\n     * Note: in the case where the window being shown as a popup needs to be created, it is a child of the caller view's parent window.\n     *\n     * @example\n     *\n     * Create and show a single-use popup window that returns a single result to the caller. `initialOptions` allows\n     * us to pass window options to the popup window that will be created. `resultDispatchBehavior: 'close'` ensures\n     * that once the popup window calls `dispatchPopupResult` it is closed. `blurBehavior: 'close'` will yield a dismissed\n     * result should the popup window lose focus.\n     *\n     * ```js\n     * const result = await fin.me.showPopupWindow({\n     *     initialOptions: {\n     *         frame: false\n     *     },\n     *     url: '<my_popup_url>',\n     *     resultDispatchBehavior: 'close',\n     *     blurBehavior: 'close',\n     *     focus: true,\n     *     height: 300,\n     *     width: 300,\n     *     x: 0,\n     *     y: 0\n     * });\n     * ```\n     *\n     * Same as above but using an existing window as a popup by referencing its `name`:\n     *\n     * Note: if a window with the `name` provided doesn't exist, it will be created.\n     *\n     * ```js\n     * const result = await fin.me.showPopupWindow({\n     *     initialOptions: {\n     *         frame: true\n     *     },\n     *     name: 'my-popup', // shows the 'my-popup' window if it exists, otherwise creates it\n     *     url: '<my_popup_url>', // navigates to this url if it doesn't match the location.href of the 'my-popup' window\n     *     resultDispatchBehavior: 'close',\n     *     blurBehavior: 'close',\n     *     focus: true,\n     *     hideOnClose: true, // persist window on 'dismissed' result, alternatively change onResultDispatch and blurBehavior to 'hide'\n     *     height: 300,\n     *     width: 300,\n     *     x: 0,\n     *     y: 0\n     * });\n     * ```\n     *\n     * Create and show a popup window that is able to return multiple results to the caller via an `onPopupResult` callback. Each\n     * time the popup window calls `dispatchPopupResult`, the callback will be executed on the result. Once the popup window is\n     * closed or hidden, the `showPopupWindow` promise will resolve with a `dismissed` result that will include the most recently\n     * dispatched result as `lastDispatchResult`:\n     *\n     * ```js\n     * const popupResultCallback = (payload) => {\n     *        if (payload.result === 'clicked') {\n     *            if (payload.data.topic === 'color-changed') {\n     *                // do something like\n     *                // setColor(payload.data.value);\n     *            }\n     *        }\n     * };\n     *\n     * await fin.me.showPopupWindow({\n     *     initialOptions: {\n     *         frame: false\n     *     },\n     *     url: '<my_popup_url>',\n     *     resultDispatchBehavior: 'none',\n     *     blurBehavior: 'close',\n     *     focus: true,\n     *     height: 300,\n     *     width: 300,\n     *     x: 0,\n     *     y: 0,\n     *     onPopupResult: popupResultCallback\n     * });\n     * ```\n     *\n     * Same as above but using an existing window as a popup:\n     *\n     * ```js\n     * const popupResultCallback = (payload) => {\n     *        if (payload.result === 'clicked') {\n     *            if (payload.data.topic === 'color-changed') {\n     *                // do something like\n     *                // setColor(payload.data.value);\n     *            }\n     *        }\n     * };\n     *\n     * await fin.me.showPopupWindow({\n     *     initialOptions: {\n     *         frame: false\n     *     },\n     *     name: 'my-popup', // shows the 'my-popup' window if it exists, otherwise creates it\n     *     url: '<my_popup_url>', // navigates to this url if it doesn't match the location.href of the 'my-popup' window\n     *     resultDispatchBehavior: 'none',\n     *     blurBehavior: 'hide',\n     *     focus: true,\n     *     hideOnClose: true, // we can just use this or we can change blurBehavior to 'hide'\n     *     height: 300,\n     *     width: 300,\n     *     x: 0,\n     *     y: 0,\n     *     onPopupResult: popupResultCallback\n     * });\n     * ```\n     *\n     * Create or show a popup window that disables user movement (positioning and resizing) in the caller\n     * view's parent window by using `blurBehavior: 'modal'`:\n     *\n     * ```js\n     * const result = await fin.me.showPopupWindow({\n     *     initialOptions: {\n     *         frame: false\n     *     },\n     *     url: '<my_popup_url>',\n     *     resultDispatchBehavior: 'close',\n     *     blurBehavior: 'modal',\n     *     focus: true,\n     *     height: 300,\n     *     width: 300,\n     *     x: 0,\n     *     y: 0\n     * });\n     * ```\n     *\n     * Create a popup window as a modal:\n     *\n     * Note: The only way to ensure true modal behavior is to create the window being shown as a popup with a\n     * `modalParentIdentity` that uses the caller view's parent window identity.\n     *\n     * ```js\n     * const result = await fin.me.showPopupWindow({\n     *     initialOptions: {\n     *         frame: false,\n     *         modalParentIdentity: fin.me.identity\n     *     },\n     *     url: '<my_popup_url>',\n     *     resultDispatchBehavior: 'close',\n     *     blurBehavior: 'modal',\n     *     focus: true,\n     *     height: 300,\n     *     width: 300,\n     *     x: 0,\n     *     y: 0\n     * });\n     * ```\n     *\n     * Pass data to a popup window that is available when the popup is shown.\n     *\n     * Note: this is just one example for a use of `additionalOptions`, it can be used to update any updatable\n     * window options when creating or showing an existing window as a popup.\n     *\n     * ```js\n     * const result = await fin.me.showPopupWindow({\n     *     additionalOptions: {\n     *         customData: {\n     *             foo: 'bar'\n     *         }\n     *     },\n     *     url: '<my_popup_url>',\n     *     resultDispatchBehavior: 'close',\n     *     blurBehavior: 'close',\n     *     focus: true,\n     *     height: 300,\n     *     width: 300,\n     *     x: 0,\n     *     y: 0\n     * });\n     *\n     * // Access from the popup window context like so:\n     * const { customData } = await fin.me.getOptions();\n     * const { foo } = customData;\n     * ```\n     *\n     * Execute a callback on the popup's OpenFin window when the popup is shown:\n     *\n     * ```js\n     * const popupWindowCallback = async (win) => {\n     *     await win.flash();\n     * };\n     *\n     * const result = await fin.me.showPopupWindow({\n     *     url: '<my_popup_url>',\n     *     resultDispatchBehavior: 'close',\n     *     blurBehavior: 'close',\n     *     focus: true,\n     *     height: 300,\n     *     width: 300,\n     *     x: 0,\n     *     y: 0,\n     *     onPopupReady: popupWindowCallback;\n     * });\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    async showPopupWindow(options) {\n        this.wire.sendAction(`${this.entityType}-show-popup-window`, this.identity).catch(() => {\n            // we do not want to expose this error, just continue if this analytics-only call fails\n        });\n        if (options?.onPopupReady) {\n            const readyListener = async ({ popupName }) => {\n                try {\n                    const popupWindow = this.fin.Window.wrapSync({ uuid: this.fin.me.uuid, name: popupName });\n                    await options.onPopupReady(popupWindow);\n                }\n                catch (error) {\n                    throw new Error(`Something went wrong during onPopupReady execution: ${error}`);\n                }\n            };\n            // TODO: fix typing (internal)\n            // @ts-expect-error\n            await this.once('popup-ready', readyListener);\n        }\n        const { payload: tryCreatePayload } = await this.wire.sendAction('try-create-popup-window', {\n            options: {\n                ...options,\n                // Internal use only.\n                // @ts-expect-error\n                hasResultCallback: !!options?.onPopupResult,\n                hasReadyCallback: !!options?.onPopupReady\n            },\n            ...this.identity\n        });\n        const { data: { willOpen, options: popupOptions } } = tryCreatePayload;\n        if (willOpen) {\n            // Solve the issue where Interop in a popup window with non cross-origin url is not working(core-1076).\n            await this.fin.Window.create(popupOptions.initialOptions);\n        }\n        const normalizePopupResult = (payload) => {\n            const { name, uuid, result, data } = payload;\n            const popupResult = {\n                identity: {\n                    name,\n                    uuid\n                },\n                result\n            };\n            if (data) {\n                popupResult.data = data;\n            }\n            return popupResult;\n        };\n        if (options?.onPopupResult) {\n            const dispatchResultListener = async (payload) => {\n                await options.onPopupResult(normalizePopupResult(payload));\n            };\n            const teardownListener = async () => {\n                // TODO: fix typing (internal)\n                // @ts-expect-error\n                await this.removeListener('popup-result', dispatchResultListener);\n            };\n            // TODO: fix typing (internal)\n            // @ts-expect-error\n            await this.on('popup-result', dispatchResultListener);\n            // TODO: fix typing (internal)\n            // hilariously this does not need a ts-expect-error - this is gap in type soundness\n            // should investigate - probably due to `teardownListener` taking a void argument\n            // which might play nicely with the `never` type?  huh...\n            await this.once('popup-teardown', teardownListener);\n        }\n        const { payload } = await this.wire.sendAction('show-popup-window', {\n            options: popupOptions,\n            ...this.identity\n        });\n        return payload.data;\n    }\n}\nmain.WebContents = WebContents;\n\nvar hasRequiredInstance$2;\n\nfunction requireInstance$2 () {\n\tif (hasRequiredInstance$2) return Instance$5;\n\thasRequiredInstance$2 = 1;\n\tvar __classPrivateFieldGet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n\t    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n\t    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n\t    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n\t};\n\tvar _View_providerChannelClient;\n\tObject.defineProperty(Instance$5, \"__esModule\", { value: true });\n\tInstance$5.View = void 0;\n\tconst transport_errors_1 = transportErrors;\n\tconst lazy_1 = lazy;\n\tconst layout_entities_1 = layoutEntities;\n\tconst layout_constants_1 = layout_constants;\n\tconst main_1 = main;\n\tconst window_1 = requireWindow();\n\t/**\n\t * A View can be used to embed additional web content into a Window.\n\t * It is like a child window, except it is positioned relative to its owning window.\n\t * It has the ability to listen for {@link OpenFin.ViewEvents View-specific events}.\n\t *\n\t * By default, a View will try to share the same renderer process as other Views owned by its parent Application.\n\t * To change that behavior, see the processAffinity {@link OpenFin.ViewOptions view option}.\n\t *\n\t * A View's lifecycle is tied to its owning window and can be re-attached to a different window at any point during its lifecycle.\n\t */\n\tclass View extends main_1.WebContents {\n\t    /**\n\t     * @internal\n\t     */\n\t    constructor(wire, identity) {\n\t        super(wire, identity, 'view');\n\t        this.identity = identity;\n\t        _View_providerChannelClient.set(this, new lazy_1.Lazy(() => {\n\t            const platform = this.fin.Platform.wrapSync(this.identity);\n\t            return platform.getClient();\n\t        }));\n\t        /**\n\t         * Attaches the current view to the given window identity.\n\t         * Identity must be the identity of a window in the same application.\n\t         * This detaches the view from its current window, and sets the view to be destroyed when its new window closes.\n\t         *\n\t         * @example\n\t         * ```js\n\t         * let view;\n\t         * async function createView() {\n\t         *     const me = await fin.Window.getCurrent();\n\t         *     return fin.View.create({\n\t         *         name: 'viewNameAttach',\n\t         *         target: me.identity,\n\t         *         bounds: {top: 10, left: 10, width: 200, height: 200}\n\t         *     });\n\t         * }\n\t         *\n\t         * async function attachView() {\n\t         *     view = await createView();\n\t         *     console.log('View created.');\n\t         *\n\t         *     await view.navigate('https://google.com');\n\t         *     console.log('View navigated to given url.');\n\t         *\n\t         *     const winOption = {\n\t         *         name:'winOptionName',\n\t         *         defaultWidth: 300,\n\t         *         defaultHeight: 300,\n\t         *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.create.html',\n\t         *         frame: true,\n\t         *         autoShow: true\n\t         *     };\n\t         *     const newWindow = await fin.Window.create(winOption);\n\t         *     view.attach(newWindow.identity);\n\t         * }\n\t         *\n\t         * attachView()\n\t         *     .then(() => console.log('View attached to new window.'))\n\t         *     .catch(err => console.log(err));\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.attach = async (target) => {\n\t            await this.wire.sendAction('attach-view', { target, ...this.identity });\n\t        };\n\t        /**\n\t         * Destroys the current view\n\t         *\n\t         * @example\n\t         * ```js\n\t         * const view = fin.View.wrapSync({ uuid: 'viewUuid', name: 'viewName' });\n\t         * view.destroy();\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.destroy = async () => {\n\t            await this.wire.sendAction('destroy-view', { ...this.identity });\n\t        };\n\t        /**\n\t         * Shows the current view if it is currently hidden.\n\t         *\n\t         * @example\n\t         * ```js\n\t         * let view;\n\t         * async function createView() {\n\t         *     const me = await fin.Window.getCurrent();\n\t         *     return fin.View.create({\n\t         *         name: 'viewNameShow',\n\t         *         target: me.identity,\n\t         *         bounds: {top: 10, left: 10, width: 200, height: 200}\n\t         *     });\n\t         * }\n\t         *\n\t         * async function hideAndShowView() {\n\t         *     view = await createView();\n\t         *     console.log('View created.');\n\t         *\n\t         *     await view.navigate('https://google.com');\n\t         *     console.log('View navigated to given url option.');\n\t         *\n\t         *     await view.hide();\n\t         *     console.log(\"View hidden.\");\n\t         *\n\t         *     view.show();\n\t         *     console.log(\"View shown.\");\n\t         * }\n\t         *\n\t         * hideAndShowView()\n\t         *     .then(() => console.log('View hidden and shown.'))\n\t         *     .catch(err => console.log(err));\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.show = async () => {\n\t            await this.wire.sendAction('show-view', { ...this.identity });\n\t        };\n\t        /**\n\t         * Sets the bounds (top, left, width, height) of the view relative to its window and shows it if it is hidden.\n\t         * This method ensures the view is both positioned and showing. It will reposition a visible view and both show and reposition a hidden view.\n\t         *\n\t         * @remarks View position is relative to the bounds of the window.\n\t         * ({top: 0, left: 0} represents the top left corner of the window)\n\t         *\n\t         * @example\n\t         * ```js\n\t         * let view;\n\t         * async function createView() {\n\t         *     const me = await fin.Window.getCurrent();\n\t         *     return fin.View.create({\n\t         *         name: 'viewNameSetBounds',\n\t         *         target: me.identity,\n\t         *         bounds: {top: 10, left: 10, width: 200, height: 200}\n\t         *     });\n\t         * }\n\t         *\n\t         * async function showViewAt() {\n\t         *     view = await createView();\n\t         *     console.log('View created.');\n\t         *\n\t         *     await view.navigate('https://google.com');\n\t         *     console.log('View navigated to given url.');\n\t         *\n\t         *     await view.showAt({\n\t         *         top: 100,\n\t         *         left: 100,\n\t         *         width: 300,\n\t         *         height: 300\n\t         *     }, {\n\t         *       bringToFront : true\n\t         *     });\n\t         * }\n\t         *\n\t         * showViewAt()\n\t         *     .then(() => console.log('View set to new bounds and shown.'))\n\t         *     .catch(err => console.log(err));\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.showAt = async (bounds, options = {}) => {\n\t            await this.wire.sendAction('show-view-at', { bounds, ...this.identity, options });\n\t        };\n\t        /**\n\t         * Brings the specified view to the front of its current window. This ensures the view will be visible on top of any other views\n\t         * which have overlapping bounds with it.\n\t         *\n\t         * Please note, this is not a permanent action - when a new view is created or attached to the window, it will display on top of all other views\n\t         * in the window that share bounds with it.\n\t         */\n\t        this.bringToFront = async () => {\n\t            await this.wire.sendAction('bring-view-to-front', { ...this.identity });\n\t        };\n\t        /**\n\t         * Hides the current view if it is currently visible.\n\t         *\n\t         * @example\n\t         * ```js\n\t         * let view;\n\t         * async function createView() {\n\t         *     const me = await fin.Window.getCurrent();\n\t         *     return fin.View.create({\n\t         *         name: 'viewNameHide',\n\t         *         target: me.identity,\n\t         *         bounds: {top: 10, left: 10, width: 200, height: 200}\n\t         *     });\n\t         * }\n\t         *\n\t         * async function hideView() {\n\t         *     view = await createView();\n\t         *     console.log('View created.');\n\t         *\n\t         *     await view.navigate('https://google.com');\n\t         *     console.log('View navigated to given url.');\n\t         *\n\t         *     await view.hide();\n\t         * }\n\t         *\n\t         * hideView()\n\t         *     .then(() => console.log('View hidden.'))\n\t         *     .catch(err => console.log(err));\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.hide = async () => {\n\t            await this.wire.sendAction('hide-view', { ...this.identity });\n\t        };\n\t        /**\n\t         * Sets the bounds (top, left, width, height) of the view relative to its window.\n\t         *\n\t         * @remarks View position is relative to the bounds of the window.\n\t         * ({top: 0, left: 0} represents the top left corner of the window)\n\t         *\n\t         * @example\n\t         * ```js\n\t         * let view;\n\t         * async function createView() {\n\t         *     const me = await fin.Window.getCurrent();\n\t         *     return fin.View.create({\n\t         *         name: 'viewNameSetBounds',\n\t         *         target: me.identity,\n\t         *         bounds: {top: 10, left: 10, width: 200, height: 200}\n\t         *     });\n\t         * }\n\t         *\n\t         * async function setViewBounds() {\n\t         *     view = await createView();\n\t         *     console.log('View created.');\n\t         *\n\t         *     await view.navigate('https://google.com');\n\t         *     console.log('View navigated to given url.');\n\t         *\n\t         *     await view.setBounds({\n\t         *         top: 100,\n\t         *         left: 100,\n\t         *         width: 300,\n\t         *         height: 300\n\t         *     });\n\t         * }\n\t         *\n\t         * setViewBounds()\n\t         *     .then(() => console.log('View set to new bounds.'))\n\t         *     .catch(err => console.log(err));\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.setBounds = async (bounds) => {\n\t            await this.wire.sendAction('set-view-bounds', { bounds, ...this.identity });\n\t        };\n\t        /**\n\t         * Gets the bounds (top, left, width, height) of the view relative to its window.\n\t         *\n\t         * @remarks View position is relative to the bounds of the window.\n\t         * ({top: 0, left: 0} represents the top left corner of the window)\n\t         *\n\t         * @example\n\t         * ```js\n\t         * const view = await fin.View.create({\n\t         *     name: 'viewNameSetBounds',\n\t         *     target: fin.me.identity,\n\t         *     bounds: {top: 10, left: 10, width: 200, height: 200}\n\t         * });\n\t         *\n\t         * await view.navigate('https://google.com');\n\t         *\n\t         * await view.setBounds({\n\t         *     top: 100,\n\t         *     left: 100,\n\t         *     width: 300,\n\t         *     height: 300\n\t         * });\n\t         *\n\t         * console.log(await view.getBounds());\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.getBounds = async () => {\n\t            const ack = await this.wire.sendAction('get-view-bounds', { ...this.identity });\n\t            return ack.payload.data;\n\t        };\n\t        /**\n\t         * Gets the View's info.\n\t         *\n\t         * @example\n\t         * ```js\n\t         * let view;\n\t         * async function createView() {\n\t         *     const me = await fin.Window.getCurrent();\n\t         *     return fin.View.create({\n\t         *         name: 'viewNameGetInfo',\n\t         *         target: me.identity,\n\t         *         bounds: {top: 10, left: 10, width: 200, height: 200}\n\t         *     });\n\t         * }\n\t         *\n\t         * async function getViewInfo() {\n\t         *     view = await createView();\n\t         *     console.log('View created.');\n\t         *\n\t         *     await view.navigate('https://google.com');\n\t         *     console.log('View navigated to given url.');\n\t         *\n\t         *     return view.getInfo();\n\t         * }\n\t         *\n\t         * getViewInfo()\n\t         *     .then((info) => console.log('View info fetched.', info))\n\t         *     .catch(err => console.log(err));\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.getInfo = async () => {\n\t            const ack = await this.wire.sendAction('get-view-info', { ...this.identity });\n\t            return ack.payload.data;\n\t        };\n\t        /**\n\t         * Retrieves the layout for the window the view is attached to.\n\t         *\n\t         * @example\n\t         * ```js\n\t         *     //get the current View\n\t         *     const view = await fin.View.getCurrent();\n\t         *\n\t         *     //get a reference to the Layout for the Window the view is part of\n\t         *     const layout = await view.getParentLayout();\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.getParentLayout = async () => {\n\t            this.wire.sendAction('view-get-parent-layout', { ...this.identity }).catch(() => {\n\t                // don't expose\n\t            });\n\t            const layoutWindow = await this.getCurrentWindow();\n\t            let layoutWindowIdentity = layoutWindow.identity;\n\t            // TODO: CORE-1857 - when we tearout active layout or drag a view out of a window, the above identity includes the whole window info.\n\t            if (layoutWindowIdentity.identity) {\n\t                layoutWindowIdentity = layoutWindowIdentity.identity;\n\t            }\n\t            try {\n\t                const providerChannelClient = await __classPrivateFieldGet(this, _View_providerChannelClient, \"f\").getValue();\n\t                const client = await layout_entities_1.LayoutNode.newLayoutEntitiesClient(providerChannelClient, layout_constants_1.LAYOUT_CONTROLLER_ID, layoutWindowIdentity);\n\t                const layoutIdentity = await client.getLayoutIdentityForViewOrThrow(this.identity);\n\t                return this.fin.Platform.Layout.wrap(layoutIdentity);\n\t            }\n\t            catch (e) {\n\t                const allowedErrors = [\n\t                    'No action registered at target for',\n\t                    'getLayoutIdentityForViewOrThrow is not a function'\n\t                ];\n\t                if (!allowedErrors.some((m) => e.message.includes(m))) {\n\t                    throw e;\n\t                }\n\t                // fallback logic for missing endpoint\n\t                return this.fin.Platform.Layout.wrap(layoutWindowIdentity);\n\t            }\n\t        };\n\t        /**\n\t         * Gets the View's options.\n\t         *\n\t         * @example\n\t         * ```js\n\t         * let view;\n\t         * async function createView() {\n\t         *     const me = await fin.Window.getCurrent();\n\t         *     return fin.View.create({\n\t         *         name: 'viewNameGetOptions',\n\t         *         target: me.identity,\n\t         *         bounds: {top: 10, left: 10, width: 200, height: 200}\n\t         *     });\n\t         * }\n\t         *\n\t         * async function getViewOptions() {\n\t         *     view = await createView();\n\t         *     console.log('View created.');\n\t         *\n\t         *     await view.navigate('https://google.com');\n\t         *     console.log('View navigated to given url.');\n\t         *\n\t         *     const me = await fin.Window.getCurrent();\n\t         *     view = fin.View.wrapSync({ uuid: me.identity.uuid, name: 'viewNameGetOptions' });\n\t         *     return view.getOptions();\n\t         * }\n\t         *\n\t         * getViewOptions()\n\t         *     .then((info) => console.log('View options fetched.', info))\n\t         *     .catch(err => console.log(err));\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.getOptions = async () => {\n\t            return this.wire.sendAction('get-view-options', { ...this.identity }).then(({ payload }) => payload.data);\n\t        };\n\t        /**\n\t         * Updates the view's options.\n\t         *\n\t         * @example\n\t         * ```js\n\t         * let view;\n\t         * async function createView() {\n\t         *     const me = await fin.Window.getCurrent();\n\t         *     return fin.View.create({\n\t         *         url: 'https://google.com',\n\t         *         name: 'viewNameUpdateOptions',\n\t         *         target: me.identity,\n\t         *         bounds: {top: 10, left: 10, width: 200, height: 200}\n\t         *     });\n\t         * }\n\t         *\n\t         * async function updateViewOptions() {\n\t         *     view = await createView();\n\t         *     console.log('View created.');\n\t         *\n\t         *     await view.navigate('https://google.com');\n\t         *     console.log('View navigated to given url option.');\n\t         *\n\t         *     const newOptions = { autoResize: {\n\t         *         width: true,\n\t         *         horizontal: true\n\t         *     }};\n\t         *     return view.updateOptions(newOptions);\n\t         * }\n\t         *\n\t         * updateViewOptions()\n\t         *     .then(payload => console.log('View options updated: ', payload))\n\t         *     .catch(err => console.log(err));\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.updateOptions = async (options) => {\n\t            return this.wire.sendAction('update-view-options', { options, ...this.identity }).then(() => undefined);\n\t        };\n\t        /**\n\t         * Retrieves the window the view is currently attached to.\n\t         *\n\t         * @example\n\t         * ```js\n\t         * const view = fin.View.wrapSync({ uuid: 'viewUuid', name: 'viewName' });\n\t         * view.getCurrentWindow()\n\t         *     .then(win => console.log('current window', win))\n\t         *     .catch(err => console.log(err));)\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.getCurrentWindow = async () => {\n\t            const { payload: { data } } = await this.wire.sendAction('get-view-window', { ...this.identity });\n\t            return new window_1._Window(this.wire, data);\n\t        };\n\t        /**\n\t         * Retrieves the current {@link OpenFin.TabStack} of the view if it belongs to one.\n\t         * @returns this view belongs to.\n\t         * @throws if this view does not belong to a TabStack or if the window has been destroyed.\n\t         * @example\n\t         * ```js\n\t         * if (!fin.me.isView) {\n\t         *     throw new Error('Not running in a platform View.');\n\t         * }\n\t         *\n\t         * const stack = await fin.me.getCurrentStack();\n\t         * // Alternatively, you can wrap any view and get the stack from there\n\t         * // const viewFromSomewhere = fin.View.wrapSync(someView.identity);\n\t         * // const stack = await viewFromSomewhere.getCurrentStack();\n\t         * const views = await stack.getViews();\n\t         * console.log(`Stack contains ${views.length} view(s)`);\n\t         * ```\n\t         */\n\t        this.getCurrentStack = async () => {\n\t            this.wire.sendAction('view-get-current-stack').catch(() => {\n\t                // don't expose\n\t            });\n\t            try {\n\t                const layoutWindow = await this.getCurrentWindow();\n\t                const providerChannelClient = await __classPrivateFieldGet(this, _View_providerChannelClient, \"f\").getValue();\n\t                const client = await layout_entities_1.LayoutNode.newLayoutEntitiesClient(providerChannelClient, layout_constants_1.LAYOUT_CONTROLLER_ID, layoutWindow.identity);\n\t                const stackDefinition = (await client.getStackByView(this.identity));\n\t                return layout_entities_1.LayoutNode.getEntity(stackDefinition, client);\n\t            }\n\t            catch (error) {\n\t                throw new transport_errors_1.RuntimeError({ reason: 'This view does not belong to a stack.', error });\n\t            }\n\t        };\n\t        /**\n\t         * Triggers the before-unload handler for the View, if one is set.\n\t         *\n\t         * @remarks Returns `true` if the handler is trying to prevent the View from unloading, and `false` if it isn't.\n\t         * Only enabled when setting enableBeforeUnload: true in your View options. If this option is not enabled it will\n\t         * always return false.\n\t         *\n\t         * This method is used internally by the Platform Provider to determine the status of each before unload handler in Views when closing the Window.\n\t         *\n\t         * @example\n\t         *\n\t         * ```js\n\t         * // from inside a View context\n\t         * const unloadPrevented = await fin.me.triggerBeforeUnload();\n\t         * ```\n\t         *\n\t         * @experimental\n\t         */\n\t        this.triggerBeforeUnload = async () => {\n\t            const message = await this.wire.sendAction('trigger-before-unload', { ...this.identity });\n\t            return message.payload.data;\n\t        };\n\t        /**\n\t         * **NOTE**: Internal use only.\n\t         * Attaches this view to an HTML element in the current context. The view will resize responsively when the element bounds change.\n\t         *\n\t         * **Known issue**: View.bindToElement does not track position changes, if the element has fixed px width and height values it is possible for the view to not update responsively.\n\t         *\n\t         * **Known issue**: When View.bindToElement is used on a element that takes up the entire page in a platform window, the bound view will not respond responsively when the window is resized to be smaller.\n\t         *\n\t         * @param element - HTML element to attach the view to.\n\t         * @returns - Cleanup function that will disconnect the element resize observer.\n\t         * @internal\n\t         * @experimental\n\t         * @remarks View will resize accordingly when the element is resized. If the element is repositioned in the DOM the view will not be repositioned, to handle this case call `bindToElement` again once the element changes position.\n\t         *\n\t         * @example\n\t         * ```html\n\t         * <div id=\"view-container\"></div>\n\t         * <script>\n\t         *     async function createAndAttachView() {\n\t         *         const url = 'https://example.com';\n\t         *         const elementId = 'view-container';\n\t         *         const element = document.getElementById(elementId);\n\t         *         const view = await fin.View.create({\n\t         *             name: 'my-view',\n\t         *             url,\n\t         *             target: fin.me.identity\n\t         *         });\n\t         *         await view.navigate(url);\n\t         *         await view.bindToElement(element);\n\t         *     }\n\t         *     createAndAttachView().catch(console.error);\n\t         * </script>\n\t         * ```\n\t         */\n\t        this.bindToElement = async (element) => {\n\t            if (!element) {\n\t                throw new Error('Element not found.');\n\t            }\n\t            const onChange = async (bounds) => this.setBounds(bounds);\n\t            return this.wire.environment.observeBounds(element, onChange);\n\t        };\n\t    }\n\t    /**\n\t     * Focuses the view\n\t     *\n\t     * @example\n\t     * ```js\n\t     * const view = fin.View.wrapSync({ uuid: 'viewUuid', name: 'viewName' });\n\t     * await view.focus();\n\t     * // do things with the focused view\n\t     * ```\n\t     * @experimental\n\t     */\n\t    async focus({ emitSynthFocused } = { emitSynthFocused: true }) {\n\t        const win = await this.getCurrentWindow();\n\t        await win.focusedWebViewWasChanged();\n\t        await super.focus({ emitSynthFocused });\n\t    }\n\t}\n\tInstance$5.View = View;\n\t_View_providerChannelClient = new WeakMap();\n\treturn Instance$5;\n}\n\nvar hasRequiredView;\n\nfunction requireView () {\n\tif (hasRequiredView) return view;\n\thasRequiredView = 1;\n\t(function (exports) {\n\t\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t\t    if (k2 === undefined) k2 = k;\n\t\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t\t    }\n\t\t    Object.defineProperty(o, k2, desc);\n\t\t}) : (function(o, m, k, k2) {\n\t\t    if (k2 === undefined) k2 = k;\n\t\t    o[k2] = m[k];\n\t\t}));\n\t\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t\t};\n\t\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t\t/**\n\t\t * Entry points for the OpenFin `View` API (`fin.View`).\n\t\t *\n\t\t * * {@link ViewModule} contains static members of the `View` API, accessible through `fin.View`.\n\t\t * * {@link View} describes an instance of an OpenFin View, e.g. as returned by `fin.View.getCurrent`.\n\t\t *\n\t\t * These are separate code entities, and are documented separately.  In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/32.114.76.10/index.html),\n\t\t * both of these were documented on the same page.\n\t\t *\n\t\t * @packageDocumentation\n\t\t */\n\t\t__exportStar(requireFactory$3(), exports);\n\t\t__exportStar(requireInstance$2(), exports); \n\t} (view));\n\treturn view;\n}\n\nvar hasRequiredInstance$1;\n\nfunction requireInstance$1 () {\n\tif (hasRequiredInstance$1) return Instance$6;\n\thasRequiredInstance$1 = 1;\n\tObject.defineProperty(Instance$6, \"__esModule\", { value: true });\n\tInstance$6.Application = void 0;\n\t/* eslint-disable import/prefer-default-export */\n\tconst base_1 = base;\n\tconst window_1 = requireWindow();\n\tconst view_1 = requireView();\n\t/**\n\t * An object representing an application. Allows the developer to create,\n\t * execute, show/close an application as well as listen to {@link OpenFin.ApplicationEvents application events}.\n\t */\n\tclass Application extends base_1.EmitterBase {\n\t    /**\n\t     * @internal\n\t     */\n\t    constructor(wire, identity) {\n\t        super(wire, 'application', identity.uuid);\n\t        this.identity = identity;\n\t        this.window = new window_1._Window(this.wire, {\n\t            uuid: this.identity.uuid,\n\t            name: this.identity.uuid\n\t        });\n\t    }\n\t    windowListFromIdentityList(identityList) {\n\t        const windowList = [];\n\t        identityList.forEach((identity) => {\n\t            windowList.push(new window_1._Window(this.wire, {\n\t                uuid: identity.uuid,\n\t                name: identity.name\n\t            }));\n\t        });\n\t        return windowList;\n\t    }\n\t    /**\n\t     * Determines if the application is currently running.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function isAppRunning() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.isRunning();\n\t     * }\n\t     * isAppRunning().then(running => console.log(`Current app is running: ${running}`)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    isRunning() {\n\t        return this.wire.sendAction('is-application-running', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Closes the application and any child windows created by the application.\n\t     * Cleans the application from state so it is no longer found in getAllApplications.\n\t     * @param force Close will be prevented from closing when force is false and\n\t     *  ‘close-requested’ has been subscribed to for application’s main window.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function closeApp() {\n\t     *     const allApps1 = await fin.System.getAllApplications(); //[{uuid: 'app1', isRunning: true}, {uuid: 'app2', isRunning: true}]\n\t     *     const app = await fin.Application.wrap({uuid: 'app2'});\n\t     *     await app.quit();\n\t     *     const allApps2 = await fin.System.getAllApplications(); //[{uuid: 'app1', isRunning: true}]\n\t     *\n\t     * }\n\t     * closeApp().then(() => console.log('Application quit')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    async quit(force = false) {\n\t        try {\n\t            await this._close(force);\n\t            await this.wire.sendAction('destroy-application', { force, ...this.identity });\n\t        }\n\t        catch (error) {\n\t            const acceptableErrors = ['Remote connection has closed', 'Could not locate the requested application'];\n\t            if (!acceptableErrors.some((msg) => error.message.includes(msg))) {\n\t                throw error;\n\t            }\n\t        }\n\t    }\n\t    async _close(force = false) {\n\t        try {\n\t            await this.wire.sendAction('close-application', { force, ...this.identity });\n\t        }\n\t        catch (error) {\n\t            if (!error.message.includes('Remote connection has closed')) {\n\t                throw error;\n\t            }\n\t        }\n\t    }\n\t    /**\n\t     * @deprecated use Application.quit instead\n\t     * Closes the application and any child windows created by the application.\n\t     * @param force - Close will be prevented from closing when force is false and ‘close-requested’ has been subscribed to for application’s main window.\n\t     * @param callback - called if the method succeeds.\n\t     * @param errorCallback - called if the method fails. The reason for failure is passed as an argument.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function closeApp() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.close();\n\t     * }\n\t     * closeApp().then(() => console.log('Application closed')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    close(force = false) {\n\t        console.warn('Deprecation Warning: Application.close is deprecated Please use Application.quit');\n\t        this.wire.sendAction('application-close', this.identity).catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return this._close(force);\n\t    }\n\t    /**\n\t     * Retrieves an array of wrapped fin.Windows for each of the application’s child windows.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function getChildWindows() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.getChildWindows();\n\t     * }\n\t     *\n\t     * getChildWindows().then(children => console.log(children)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getChildWindows() {\n\t        return this.wire.sendAction('get-child-windows', this.identity).then(({ payload }) => {\n\t            const identityList = [];\n\t            payload.data.forEach((winName) => {\n\t                identityList.push({ uuid: this.identity.uuid, name: winName });\n\t            });\n\t            return this.windowListFromIdentityList(identityList);\n\t        });\n\t    }\n\t    /**\n\t     * Retrieves the JSON manifest that was used to create the application. Invokes the error callback\n\t     * if the application was not created from a manifest.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function getManifest() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.getManifest();\n\t     * }\n\t     *\n\t     * getManifest().then(manifest => console.log(manifest)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getManifest() {\n\t        return this.wire.sendAction('get-application-manifest', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Retrieves UUID of the application that launches this application. Invokes the error callback\n\t     * if the application was created from a manifest.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function getParentUuid() {\n\t     *     const app = await fin.Application.start({\n\t     *         uuid: 'app-1',\n\t     *         name: 'myApp',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Application.getParentUuid.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getParentUuid();\n\t     * }\n\t     *\n\t     * getParentUuid().then(parentUuid => console.log(parentUuid)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getParentUuid() {\n\t        return this.wire.sendAction('get-parent-application', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Retrieves current application's shortcut configuration.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function getShortcuts() {\n\t     *     const app = await fin.Application.wrap({ uuid: 'testapp' });\n\t     *     return await app.getShortcuts();\n\t     * }\n\t     * getShortcuts().then(config => console.log(config)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getShortcuts() {\n\t        return this.wire.sendAction('get-shortcuts', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Retrieves current application's views.\n\t     * @experimental\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function getViews() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.getViews();\n\t     * }\n\t     * getViews().then(views => console.log(views)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    async getViews() {\n\t        const { payload } = await this.wire.sendAction('application-get-views', this.identity);\n\t        return payload.data.map((id) => new view_1.View(this.wire, id));\n\t    }\n\t    /**\n\t     * Returns the current zoom level of the application.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function getZoomLevel() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.getZoomLevel();\n\t     * }\n\t     *\n\t     * getZoomLevel().then(zoomLevel => console.log(zoomLevel)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getZoomLevel() {\n\t        return this.wire.sendAction('get-application-zoom-level', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Returns an instance of the main Window of the application\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function getWindow() {\n\t     *     const app = await fin.Application.start({\n\t     *         uuid: 'app-1',\n\t     *         name: 'myApp',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Application.getWindow.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     *\n\t     * getWindow().then(win => {\n\t     *     win.showAt(0, 400);\n\t     *     win.flash();\n\t     * }).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getWindow() {\n\t        this.wire.sendAction('application-get-window', this.identity).catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return Promise.resolve(this.window);\n\t    }\n\t    /**\n\t     * Manually registers a user with the licensing service. The only data sent by this call is userName and appName.\n\t     * @param userName - username to be passed to the RVM.\n\t     * @param appName - app name to be passed to the RVM.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function registerUser() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.registerUser('user', 'myApp');\n\t     * }\n\t     *\n\t     * registerUser().then(() => console.log('Successfully registered the user')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    registerUser(userName, appName) {\n\t        return this.wire.sendAction('register-user', { userName, appName, ...this.identity }).then(() => undefined);\n\t    }\n\t    /**\n\t     * Removes the application’s icon from the tray.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function removeTrayIcon() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.removeTrayIcon();\n\t     * }\n\t     *\n\t     * removeTrayIcon().then(() => console.log('Removed the tray icon.')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    removeTrayIcon() {\n\t        return this.wire.sendAction('remove-tray-icon', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Restarts the application.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function restartApp() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.restart();\n\t     * }\n\t     * restartApp().then(() => console.log('Application restarted')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    restart() {\n\t        return this.wire.sendAction('restart-application', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * DEPRECATED method to run the application.\n\t     * Needed when starting application via {@link Application.create}, but NOT needed when starting via {@link Application.start}.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function run() {\n\t     *     const app = await fin.Application.create({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Application.run.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     await app.run();\n\t     * }\n\t     * run().then(() => console.log('Application is running')).catch(err => console.log(err));\n\t     * ```\n\t     *\n\t     * @ignore\n\t     */\n\t    run() {\n\t        console.warn('Deprecation Warning: Application.run is deprecated Please use fin.Application.start');\n\t        this.wire.sendAction('application-run', this.identity).catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return this._run();\n\t    }\n\t    _run(opts = {}) {\n\t        return this.wire\n\t            .sendAction('run-application', {\n\t            manifestUrl: this._manifestUrl,\n\t            opts,\n\t            ...this.identity\n\t        })\n\t            .then(() => undefined);\n\t    }\n\t    /**\n\t     * Instructs the RVM to schedule one restart of the application.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function scheduleRestart() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.scheduleRestart();\n\t     * }\n\t     *\n\t     * scheduleRestart().then(() => console.log('Application is scheduled to restart')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    scheduleRestart() {\n\t        return this.wire.sendAction('relaunch-on-close', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Sends a message to the RVM to upload the application's logs. On success,\n\t     * an object containing logId is returned.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function sendLog() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.sendApplicationLog();\n\t     * }\n\t     *\n\t     * sendLog().then(info => console.log(info.logId)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    async sendApplicationLog() {\n\t        const { payload } = await this.wire.sendAction('send-application-log', this.identity);\n\t        return payload.data;\n\t    }\n\t    /**\n\t     * Sets or removes a custom JumpList for the application. Only applicable in Windows OS.\n\t     * If categories is null the previously set custom JumpList (if any) will be replaced by the standard JumpList for the app (managed by Windows).\n\t     *\n\t     * Note: If the \"name\" property is omitted it defaults to \"tasks\".\n\t     * @param jumpListCategories An array of JumpList Categories to populate. If null, remove any existing JumpList configuration and set to Windows default.\n\t     *\n\t     *\n\t     * @remarks If categories is null the previously set custom JumpList (if any) will be replaced by the standard JumpList for the app (managed by Windows).\n\t     *\n\t     * The bottommost item in the jumplist will always be an item pointing to the current app. Its name is taken from the manifest's\n\t     * **` shortcut.name `** and uses **` shortcut.company `** as a fallback. Clicking that item will launch the app from its current manifest.\n\t     *\n\t     * Note: If the \"name\" property is omitted it defaults to \"tasks\".\n\t     *\n\t     * Note: Window OS caches jumplists icons, therefore an icon change might only be visible after the cache is removed or the\n\t     * uuid or shortcut.name is changed.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     *     const app = fin.Application.getCurrentSync();\n\t     *     const appName = 'My App';\n\t     *     const jumpListConfig = [ // array of JumpList categories\n\t     *         {\n\t     *             // has no name and no type so `type` is assumed to be \"tasks\"\n\t     *             items: [ // array of JumpList items\n\t     *             {\n\t     *                 type: 'task',\n\t     *                 title: `Launch ${appName}`,\n\t     *                 description: `Runs ${appName} with the default configuration`,\n\t     *                 deepLink: 'fins://path.to/app/manifest.json',\n\t     *                 iconPath: 'https://path.to/app/icon.ico',\n\t     *                 iconIndex: 0\n\t     *             },\n\t     *             { type: 'separator' },\n\t     *             {\n\t     *                 type: 'task',\n\t     *                 title: `Restore ${appName}`,\n\t     *                 description: 'Restore to last configuration',\n\t     *                 deepLink: 'fins://path.to/app/manifest.json?$$use-last-configuration=true',\n\t     *                 iconPath: 'https://path.to/app/icon.ico',\n\t     *                 iconIndex: 0\n\t     *             },\n\t     *             ]\n\t     *         },\n\t     *         {\n\t     *             name: 'Tools',\n\t     *             items: [ // array of JumpList items\n\t     *             {\n\t     *                 type: 'task',\n\t     *                 title: 'Tool A',\n\t     *                 description: 'Runs Tool A',\n\t     *                 deepLink: 'fins://path.to/tool-a/manifest.json',\n\t     *                 iconPath: 'https://path.to/tool-a/icon.ico',\n\t     *                 iconIndex: 0\n\t     *             },\n\t     *             {\n\t     *                 type: 'task',\n\t     *                 title: 'Tool B',\n\t     *                 description: 'Runs Tool B',\n\t     *                 deepLink: 'fins://path.to/tool-b/manifest.json',\n\t     *                 iconPath: 'https://path.to/tool-b/icon.ico',\n\t     *                 iconIndex: 0\n\t     *             }]\n\t     *         }\n\t     *     ];\n\t     *\n\t     *     app.setJumpList(jumpListConfig).then(() => console.log('JumpList applied')).catch(e => console.log(`JumpList failed to apply: ${e.toString()}`));\n\t     * ```\n\t     *\n\t     * To handle deeplink args:\n\t     * ```js\n\t     *     function handleUseLastConfiguration() {\n\t     *         // this handler is called when the app is being launched\n\t     *         app.on('run-requested', event => {\n\t     *             if(event.userAppConfigArgs['use-last-configuration']) {\n\t     *                 // your logic here\n\t     *             }\n\t     *         });\n\t     *         // this handler is called when the app was already running when the launch was requested\n\t     *         fin.desktop.main(function(args) {\n\t     *             if(args && args['use-last-configuration']) {\n\t     *                 // your logic here\n\t     *             }\n\t     *         });\n\t     *     }\n\t     * ```\n\t     */\n\t    async setJumpList(jumpListCategories) {\n\t        await this.wire.sendAction('set-jump-list', { config: jumpListCategories, ...this.identity });\n\t    }\n\t    /**\n\t     * Adds a customizable icon in the system tray.  To listen for a click on the icon use the `tray-icon-clicked` event.\n\t     * @param icon Image URL or base64 encoded string to be used as the icon\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * const imageUrl = \"http://cdn.openfin.co/assets/testing/icons/circled-digit-one.png\";\n\t     * const base64EncodedImage = \"iVBORw0KGgoAAAANSUhEUgAAAAgAAAAIAQMAAAD+wSzIAAAABlBMVEX\\\n\t     * ///+/v7+jQ3Y5AAAADklEQVQI12P4AIX8EAgALgAD/aNpbtEAAAAASUVORK5CYII\";\n\t     * const dataURL = \"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DH\\\n\t     * xgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg==\";\n\t     *\n\t     * async function setTrayIcon(icon) {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.setTrayIcon(icon);\n\t     * }\n\t     *\n\t     * // use image url to set tray icon\n\t     * setTrayIcon(imageUrl).then(() => console.log('Setting tray icon')).catch(err => console.log(err));\n\t     *\n\t     * // use base64 encoded string to set tray icon\n\t     * setTrayIcon(base64EncodedImage).then(() => console.log('Setting tray icon')).catch(err => console.log(err));\n\t     *\n\t     * // use a dataURL to set tray icon\n\t     * setTrayIcon(dataURL).then(() => console.log('Setting tray icon')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    setTrayIcon(icon) {\n\t        return this.wire\n\t            .sendAction('set-tray-icon', {\n\t            enabledIcon: icon,\n\t            ...this.identity\n\t        })\n\t            .then(() => undefined);\n\t    }\n\t    /**\n\t     * Sets new application's shortcut configuration. Windows only.\n\t     * @param config New application's shortcut configuration.\n\t     *\n\t     * @remarks Application has to be launched with a manifest and has to have shortcut configuration (icon url, name, etc.) in its manifest\n\t     * to be able to change shortcut states.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function setShortcuts(config) {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return app.setShortcuts(config);\n\t     * }\n\t     *\n\t     * setShortcuts({\n\t     *     desktop: true,\n\t     *     startMenu: false,\n\t     *     systemStartup: true\n\t     * }).then(() => console.log('Shortcuts are set.')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    setShortcuts(config) {\n\t        return this.wire.sendAction('set-shortcuts', { data: config, ...this.identity }).then(() => undefined);\n\t    }\n\t    /**\n\t     * Sets the query string in all shortcuts for this app. Requires RVM 5.5+.\n\t     * @param queryString The new query string for this app's shortcuts.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * const newQueryArgs = 'arg=true&arg2=false';\n\t     * const app = await fin.Application.getCurrent();\n\t     * try {\n\t     *     await app.setShortcutQueryParams(newQueryArgs);\n\t     * } catch(err) {\n\t     *     console.error(err)\n\t     * }\n\t     * ```\n\t     */\n\t    async setShortcutQueryParams(queryString) {\n\t        await this.wire.sendAction('set-shortcut-query-args', { data: queryString, ...this.identity });\n\t    }\n\t    /**\n\t     * Sets the zoom level of the application. The original size is 0 and each increment above or below represents zooming 20%\n\t     * larger or smaller to default limits of 300% and 50% of original size, respectively.\n\t     * @param level The zoom level\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function setZoomLevel(number) {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.setZoomLevel(number);\n\t     * }\n\t     *\n\t     * setZoomLevel(5).then(() => console.log('Setting a  zoom level')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    setZoomLevel(level) {\n\t        return this.wire.sendAction('set-application-zoom-level', { level, ...this.identity }).then(() => undefined);\n\t    }\n\t    /**\n\t     * Sets a username to correlate with App Log Management.\n\t     * @param username Username to correlate with App's Log.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function setAppLogUser() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.setAppLogUsername('username');\n\t     * }\n\t     *\n\t     * setAppLogUser().then(() => console.log('Success')).catch(err => console.log(err));\n\t     *\n\t     * ```\n\t     */\n\t    async setAppLogUsername(username) {\n\t        await this.wire.sendAction('set-app-log-username', { data: username, ...this.identity });\n\t    }\n\t    /**\n\t     * Retrieves information about the system tray. If the system tray is not set, it will throw an error message.\n\t     * @remarks The only information currently returned is the position and dimensions.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function getTrayIconInfo() {\n\t     *     const app = await fin.Application.wrap({ uuid: 'testapp' });\n\t     *     return await app.getTrayIconInfo();\n\t     * }\n\t     * getTrayIconInfo().then(info => console.log(info)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getTrayIconInfo() {\n\t        return this.wire.sendAction('get-tray-icon-info', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Checks if the application has an associated tray icon.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * const app = await fin.Application.wrap({ uuid: 'testapp' });\n\t     * const hasTrayIcon = await app.hasTrayIcon();\n\t     * console.log(hasTrayIcon);\n\t     * ```\n\t     */\n\t    hasTrayIcon() {\n\t        return this.wire.sendAction('has-tray-icon', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Closes the application by terminating its process.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function terminateApp() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.terminate();\n\t     * }\n\t     * terminateApp().then(() => console.log('Application terminated')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    terminate() {\n\t        return this.wire.sendAction('terminate-application', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Waits for a hanging application. This method can be called in response to an application\n\t     * \"not-responding\" to allow the application to continue and to generate another \"not-responding\"\n\t     * message after a certain period of time.\n\t     *\n\t     * @ignore\n\t     */\n\t    wait() {\n\t        return this.wire.sendAction('wait-for-hung-application', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Retrieves information about the application.\n\t     *\n\t     * @remarks If the application was not launched from a manifest, the call will return the closest parent application `manifest`\n\t     * and `manifestUrl`.  `initialOptions` shows the parameters used when launched programmatically, or the `startup_app` options\n\t     * if launched from manifest. The `parentUuid` will be the uuid of the immediate parent (if applicable).\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function getInfo() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.getInfo();\n\t     * }\n\t     *\n\t     * getInfo().then(info => console.log(info)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getInfo() {\n\t        return this.wire.sendAction('get-info', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Retrieves all process information for entities (windows and views) associated with an application.\n\t     *\n\t     * @example\n\t     * ```js\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     const processInfo = await app.getProcessInfo();\n\t     * ```\n\t     * @experimental\n\t     */\n\t    async getProcessInfo() {\n\t        const { payload: { data } } = await this.wire.sendAction('application-get-process-info', this.identity);\n\t        return data;\n\t    }\n\t    /**\n\t     * Sets file auto download location. It's only allowed in the same application.\n\t     *\n\t     * Note: This method is restricted by default and must be enabled via\n\t     * <a href=\"https://developers.openfin.co/docs/api-security\">API security settings</a>.\n\t     * @param downloadLocation file auto download location\n\t     *\n\t     * @throws if setting file auto download location on different applications.\n\t     * @example\n\t     *\n\t     * ```js\n\t     * const downloadLocation = 'C:\\\\dev\\\\temp';\n\t     * const app = await fin.Application.getCurrent();\n\t     * try {\n\t     *     await app.setFileDownloadLocation(downloadLocation);\n\t     *     console.log('File download location is set');\n\t     * } catch(err) {\n\t     *     console.error(err)\n\t     * }\n\t     * ```\n\t     */\n\t    async setFileDownloadLocation(downloadLocation) {\n\t        const { name } = this.wire.me;\n\t        const entityIdentity = { uuid: this.identity.uuid, name };\n\t        await this.wire.sendAction('set-file-download-location', { ...entityIdentity, downloadLocation });\n\t    }\n\t    /**\n\t     * Gets file auto download location. It's only allowed in the same application. If file auto download location is not set, it will return the default location.\n\t     *\n\t     * Note: This method is restricted by default and must be enabled via\n\t     * <a href=\"https://developers.openfin.co/docs/api-security\">API security settings</a>.\n\t     *\n\t     * @throws if getting file auto download location on different applications.\n\t     * @example\n\t     *\n\t     * ```js\n\t     * const app = await fin.Application.getCurrent();\n\t     * const fileDownloadDir =  await app.getFileDownloadLocation();\n\t     * ```\n\t     */\n\t    async getFileDownloadLocation() {\n\t        const { payload: { data } } = await this.wire.sendAction('get-file-download-location', this.identity);\n\t        return data;\n\t    }\n\t    /**\n\t     * Shows a menu on the tray icon. Use with tray-icon-clicked event.\n\t     * @param options\n\t     * @typeParam Data User-defined shape for data returned upon menu item click. Should be a\n\t     * [union](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#union-types)\n\t     * of all possible data shapes for the entire menu, and the click handler should process\n\t     * these with a \"reducer\" pattern.\n\t     * @throws if the application has no tray icon set\n\t     * @throws if the system tray is currently hidden\n\t     * @example\n\t     *\n\t     * ```js\n\t     * const iconUrl = 'http://cdn.openfin.co/assets/testing/icons/circled-digit-one.png';\n\t     * const app = fin.Application.getCurrentSync();\n\t     *\n\t     * await app.setTrayIcon(iconUrl);\n\t     *\n\t     * const template = [\n\t     *  {\n\t     *    label: 'Menu Item 1',\n\t     *    data: 'hello from item 1'\n\t     *  },\n\t     *  { type: 'separator' },\n\t     *  {\n\t     *    label: 'Menu Item 2',\n\t     *    type: 'checkbox',\n\t     *    checked: true,\n\t     *    data: 'The user clicked the checkbox'\n\t     *  },\n\t     *  {\n\t     *    label: 'see more',\n\t     *    enabled: false,\n\t     *    submenu: [\n\t     *      { label: 'submenu 1', data: 'hello from submenu' }\n\t     *    ]\n\t     *  }\n\t     * ];\n\t     *\n\t     * app.addListener('tray-icon-clicked', (event) => {\n\t     *   // right-click\n\t     *   if (event.button === 2) {\n\t     *     app.showTrayIconPopupMenu({ template }).then(r => {\n\t     *       if (r.result === 'closed') {\n\t     *         console.log('nothing happened');\n\t     *       } else {\n\t     *         console.log(r.data);\n\t     *       }\n\t     *     });\n\t     *   }\n\t     * });\n\t     * ```\n\t     */\n\t    async showTrayIconPopupMenu(options) {\n\t        const { name } = this.wire.me;\n\t        const entityIdentity = { uuid: this.identity.uuid, name };\n\t        const { payload } = await this.wire.sendAction('show-tray-icon-popup-menu', { ...entityIdentity, options });\n\t        return payload.data;\n\t    }\n\t    /**\n\t     * Closes the tray icon menu.\n\t     *\n\t     * @throws if the application has no tray icon set\n\t     * @example\n\t     *\n\t     * ```js\n\t     * const app = fin.Application.getCurrentSync();\n\t     *\n\t     * await app.closeTrayIconPopupMenu();\n\t     * ```\n\t     */\n\t    async closeTrayIconPopupMenu() {\n\t        const { name } = this.wire.me;\n\t        const entityIdentity = { uuid: this.identity.uuid, name };\n\t        await this.wire.sendAction('close-tray-icon-popup-menu', { ...entityIdentity });\n\t    }\n\t}\n\tInstance$6.Application = Application;\n\treturn Instance$6;\n}\n\nvar hasRequiredFactory$2;\n\nfunction requireFactory$2 () {\n\tif (hasRequiredFactory$2) return Factory$7;\n\thasRequiredFactory$2 = 1;\n\tObject.defineProperty(Factory$7, \"__esModule\", { value: true });\n\tFactory$7.ApplicationModule = void 0;\n\tconst base_1 = base;\n\tconst validate_1 = validate;\n\tconst Instance_1 = requireInstance$1();\n\t/**\n\t * Static namespace for OpenFin API methods that interact with the {@link Application} class, available under `fin.Application`.\n\t */\n\tclass ApplicationModule extends base_1.Base {\n\t    /**\n\t     * Asynchronously returns an API handle for the given Application identity.\n\t     *\n\t     * @remarks Wrapping an Application identity that does not yet exist will *not* throw an error, and instead\n\t     * returns a stub object that cannot yet perform rendering tasks. This can be useful for plumbing eventing\n\t     * for an Application throughout its entire lifecycle.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * fin.Application.wrap({ uuid: 'testapp' })\n\t     * .then(app => app.isRunning())\n\t     * .then(running => console.log('Application is running: ' + running))\n\t     * .catch(err => console.log(err));\n\t     * ```\n\t     *\n\t     */\n\t    async wrap(identity) {\n\t        this.wire.sendAction('wrap-application').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const errorMsg = (0, validate_1.validateIdentity)(identity);\n\t        if (errorMsg) {\n\t            throw new Error(errorMsg);\n\t        }\n\t        return new Instance_1.Application(this.wire, identity);\n\t    }\n\t    /**\n\t     * Synchronously returns an API handle for the given Application identity.\n\t     *\n\t     * @remarks Wrapping an Application identity that does not yet exist will *not* throw an error, and instead\n\t     * returns a stub object that cannot yet perform rendering tasks. This can be useful for plumbing eventing\n\t     * for an Aplication throughout its entire lifecycle.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * const app = fin.Application.wrapSync({ uuid: 'testapp' });\n\t     * await app.close();\n\t     * ```\n\t     *\n\t     */\n\t    wrapSync(identity) {\n\t        this.wire.sendAction('wrap-application-sync').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const errorMsg = (0, validate_1.validateIdentity)(identity);\n\t        if (errorMsg) {\n\t            throw new Error(errorMsg);\n\t        }\n\t        return new Instance_1.Application(this.wire, identity);\n\t    }\n\t    async _create(appOptions) {\n\t        // set defaults:\n\t        if (appOptions.waitForPageLoad === undefined) {\n\t            appOptions.waitForPageLoad = false;\n\t        }\n\t        if (appOptions.autoShow === undefined && appOptions.isPlatformController === undefined) {\n\t            appOptions.autoShow = true;\n\t        }\n\t        await this.wire.sendAction('create-application', appOptions);\n\t        return this.wrap({ uuid: appOptions.uuid });\n\t    }\n\t    /**\n\t     * DEPRECATED method to create a new Application. Use {@link Application.ApplicationModule.start Application.start} instead.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function createApp() {\n\t     *     const app = await fin.Application.create({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-3',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Application.create.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     await app.run();\n\t     * }\n\t     *\n\t     * createApp().then(() => console.log('Application is created')).catch(err => console.log(err));\n\t     * ```\n\t     *\n\t     * @ignore\n\t     */\n\t    create(appOptions) {\n\t        console.warn('Deprecation Warning: fin.Application.create is deprecated. Please use fin.Application.start');\n\t        this.wire.sendAction('application-create').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return this._create(appOptions);\n\t    }\n\t    /**\n\t     * Creates and starts a new Application.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function start() {\n\t     *     return fin.Application.start({\n\t     *         name: 'app-1',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Application.start.html',\n\t     *         autoShow: true\n\t     *     });\n\t     * }\n\t     * start().then(() => console.log('Application is running')).catch(err => console.log(err));\n\t     * ```\n\t     *\n\t     */\n\t    async start(appOptions) {\n\t        this.wire.sendAction('start-application').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const app = await this._create(appOptions);\n\t        await this.wire.sendAction('run-application', { uuid: appOptions.uuid });\n\t        return app;\n\t    }\n\t    /**\n\t     * Asynchronously starts a batch of applications given an array of application identifiers and manifestUrls.\n\t     * Returns once the RVM is finished attempting to launch the applications.\n\t     * @param opts - Parameters that the RVM will use.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     *\n\t     * const applicationInfoArray = [\n\t     *     {\n\t     *         \"uuid\": 'App-1',\n\t     *         \"manifestUrl\": 'http://localhost:5555/app1.json',\n\t     *     },\n\t     *     {\n\t     *         \"uuid\": 'App-2',\n\t     *         \"manifestUrl\": 'http://localhost:5555/app2.json',\n\t     *     },\n\t     *     {\n\t     *         \"uuid\": 'App-3',\n\t     *         \"manifestUrl\": 'http://localhost:5555/app3.json',\n\t     *     }\n\t     * ]\n\t     *\n\t     * fin.Application.startManyManifests(applicationInfoArray)\n\t     *     .then(() => {\n\t     *         console.log('RVM has finished launching the application list.');\n\t     *     })\n\t     *     .catch((err) => {\n\t     *         console.log(err);\n\t     *     })\n\t     * ```\n\t     *\n\t     * @experimental\n\t     */\n\t    async startManyManifests(applications, opts) {\n\t        return this.wire.sendAction('run-applications', { applications, opts }).then(() => undefined);\n\t    }\n\t    /**\n\t     * Asynchronously returns an Application object that represents the current application\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function isCurrentAppRunning () {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return app.isRunning();\n\t     * }\n\t     *\n\t     * isCurrentAppRunning().then(running => {\n\t     *     console.log(`Current app is running: ${running}`);\n\t     * }).catch(err => {\n\t     *     console.error(err);\n\t     * });\n\t     *\n\t     * ```\n\t     */\n\t    getCurrent() {\n\t        this.wire.sendAction('get-current-application').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return this.wrap({ uuid: this.wire.me.uuid });\n\t    }\n\t    /**\n\t     * Synchronously returns an Application object that represents the current application\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function isCurrentAppRunning () {\n\t     *     const app = fin.Application.getCurrentSync();\n\t     *     return app.isRunning();\n\t     * }\n\t     *\n\t     * isCurrentAppRunning().then(running => {\n\t     *     console.log(`Current app is running: ${running}`);\n\t     * }).catch(err => {\n\t     *     console.error(err);\n\t     * });\n\t     *\n\t     * ```\n\t     */\n\t    getCurrentSync() {\n\t        this.wire.sendAction('get-current-application-sync').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return this.wrapSync({ uuid: this.wire.me.uuid });\n\t    }\n\t    /**\n\t     * Retrieves application's manifest and returns a running instance of the application.\n\t     * @param manifestUrl - The URL of app's manifest.\n\t     * @param opts - Parameters that the RVM will use.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * fin.Application.startFromManifest('http://localhost:5555/app.json').then(app => console.log('App is running')).catch(err => console.log(err));\n\t     *\n\t     * // For a local manifest file:\n\t     * fin.Application.startFromManifest('file:///C:/somefolder/app.json').then(app => console.log('App is running')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    async startFromManifest(manifestUrl, opts) {\n\t        this.wire.sendAction('application-start-from-manifest').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const app = await this._createFromManifest(manifestUrl);\n\t        // @ts-expect-error using private method without warning.\n\t        await app._run(opts); // eslint-disable-line no-underscore-dangle\n\t        return app;\n\t    }\n\t    /**\n\t     * @deprecated Use {@link Application.ApplicationModule.startFromManifest Application.startFromManifest} instead.\n\t     * Retrieves application's manifest and returns a wrapped application.\n\t     * @param manifestUrl - The URL of app's manifest.\n\t     * @param callback - called if the method succeeds.\n\t     * @param errorCallback - called if the method fails. The reason for failure is passed as an argument.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * fin.Application.createFromManifest('http://localhost:5555/app.json').then(app => console.log(app)).catch(err => console.log(err));\n\t     * ```\n\t     * @ignore\n\t     */\n\t    createFromManifest(manifestUrl) {\n\t        console.warn('Deprecation Warning: fin.Application.createFromManifest is deprecated. Please use fin.Application.startFromManifest');\n\t        this.wire.sendAction('application-create-from-manifest').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return this._createFromManifest(manifestUrl);\n\t    }\n\t    _createFromManifest(manifestUrl) {\n\t        return this.wire\n\t            .sendAction('get-application-manifest', { manifestUrl })\n\t            .then(({ payload }) => {\n\t            const uuid = payload.data.platform ? payload.data.platform.uuid : payload.data.startup_app.uuid;\n\t            return this.wrap({ uuid });\n\t        })\n\t            .then((app) => {\n\t            app._manifestUrl = manifestUrl; // eslint-disable-line no-underscore-dangle\n\t            return app;\n\t        });\n\t    }\n\t}\n\tFactory$7.ApplicationModule = ApplicationModule;\n\treturn Factory$7;\n}\n\nvar hasRequiredApplication;\n\nfunction requireApplication () {\n\tif (hasRequiredApplication) return application;\n\thasRequiredApplication = 1;\n\t(function (exports) {\n\t\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t\t    if (k2 === undefined) k2 = k;\n\t\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t\t    }\n\t\t    Object.defineProperty(o, k2, desc);\n\t\t}) : (function(o, m, k, k2) {\n\t\t    if (k2 === undefined) k2 = k;\n\t\t    o[k2] = m[k];\n\t\t}));\n\t\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t\t};\n\t\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t\t/**\n\t\t * Entry points for the OpenFin `Application` API (`fin.Application`).\n\t\t *\n\t\t * * {@link ApplicationModule} contains static members of the `Application` API, accessible through `fin.Application`.\n\t\t * * {@link Application} describes an instance of an OpenFin Application, e.g. as returned by `fin.Application.getCurrent`.\n\t\t *\n\t\t * These are separate code entities, and are documented separately.  In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/32.114.76.10/index.html),\n\t\t * both of these were documented on the same page.\n\t\t *\n\t\t * @packageDocumentation\n\t\t */\n\t\t__exportStar(requireFactory$2(), exports);\n\t\t__exportStar(requireInstance$1(), exports); \n\t} (application));\n\treturn application;\n}\n\nvar promisifySubscription$1 = {};\n\nObject.defineProperty(promisifySubscription$1, \"__esModule\", { value: true });\npromisifySubscription$1.promisifySubscription = void 0;\nconst promisifySubscription = async (emitter, eventName, predicate = () => true, timeout) => {\n    let resolve;\n    let reject;\n    let timer;\n    const valuePromise = new Promise((y, n) => {\n        resolve = y;\n        reject = n;\n    });\n    const listener = (e) => {\n        if (predicate(e)) {\n            clearTimeout(timer);\n            resolve(e);\n        }\n    };\n    await emitter.on(eventName, listener);\n    if (timeout) {\n        timer = setTimeout(() => reject(new Error('event timed out')), timeout);\n    }\n    valuePromise.finally(() => {\n        emitter.removeListener(eventName, listener).catch(() => null);\n    });\n    return {\n        getValue: () => valuePromise\n    };\n};\npromisifySubscription$1.promisifySubscription = promisifySubscription;\n\nvar hasRequiredInstance;\n\nfunction requireInstance () {\n\tif (hasRequiredInstance) return Instance$7;\n\thasRequiredInstance = 1;\n\tObject.defineProperty(Instance$7, \"__esModule\", { value: true });\n\tInstance$7._Window = void 0;\n\t/* eslint-disable import/prefer-default-export */\n\t/* eslint-disable @typescript-eslint/no-unused-vars */\n\t/* eslint-disable no-console */\n\t/* eslint-disable @typescript-eslint/no-non-null-assertion */\n\tconst application_1 = requireApplication();\n\tconst main_1 = main;\n\tconst view_1 = requireView();\n\tconst warnings_1 = warnings;\n\tconst promisifySubscription_1 = promisifySubscription$1;\n\t/**\n\t * A basic window that wraps a native HTML window. Provides more fine-grained\n\t * control over the window state such as the ability to minimize, maximize, restore, etc.\n\t * By default a window does not show upon instantiation; instead the window's show() method\n\t * must be invoked manually. The new window appears in the same process as the parent window.\n\t * It has the ability to listen for {@link OpenFin.WindowEvents window specific events}.\n\t */\n\t// The window.Window name is taken\n\tclass _Window extends main_1.WebContents {\n\t    /**\n\t     * @internal\n\t     */\n\t    constructor(wire, identity) {\n\t        super(wire, identity, 'window');\n\t    }\n\t    async createWindow(options) {\n\t        this.wire.sendAction('window-create-window', this.identity).catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const CONSTRUCTOR_CB_TOPIC = 'fire-constructor-callback';\n\t        const responseSubscription = await (0, promisifySubscription_1.promisifySubscription)(this, CONSTRUCTOR_CB_TOPIC);\n\t        // set defaults:\n\t        if (options.waitForPageLoad === undefined) {\n\t            options.waitForPageLoad = false;\n\t        }\n\t        if (options.autoShow === undefined) {\n\t            options.autoShow = true;\n\t        }\n\t        (0, warnings_1.handleDeprecatedWarnings)(options);\n\t        const windowCreation = this.wire.environment.createChildContent({ entityType: 'window', options });\n\t        const [response] = await Promise.all([responseSubscription.getValue(), windowCreation]);\n\t        let cbPayload;\n\t        const { success } = response;\n\t        const responseData = response.data;\n\t        const { message } = responseData;\n\t        if (success) {\n\t            cbPayload = {\n\t                httpResponseCode: responseData.httpResponseCode,\n\t                apiInjected: responseData.apiInjected\n\t            };\n\t        }\n\t        else {\n\t            cbPayload = {\n\t                message: responseData.message,\n\t                networkErrorCode: responseData.networkErrorCode,\n\t                stack: responseData.stack\n\t            };\n\t        }\n\t        const pageResolve = {\n\t            message,\n\t            cbPayload,\n\t            success\n\t        };\n\t        try {\n\t            // this is to enforce a 5.0 contract that the child's main function\n\t            // will not fire before the parent's success callback on creation.\n\t            // if the child window is not accessible (CORS) this contract does\n\t            // not hold.\n\t            const webWindow = this.getWebWindow();\n\t            webWindow.fin.__internal_.openerSuccessCBCalled();\n\t        }\n\t        catch (e) {\n\t            // common for main windows, we do not want to expose this error. here just to have a debug target.\n\t            // console.error(e);\n\t        }\n\t        if (pageResolve.success) {\n\t            return this;\n\t        }\n\t        return Promise.reject(pageResolve);\n\t    }\n\t    /**\n\t     * Retrieves an array of frame info objects representing the main frame and any\n\t     * iframes that are currently on the page.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function getAllFrames() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getAllFrames.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.getAllFrames();\n\t     * }\n\t     *\n\t     * getAllFrames().then(framesInfo => console.log(framesInfo)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getAllFrames() {\n\t        return this.wire.sendAction('get-all-frames', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Gets the current bounds (top, bottom, right, left, width, height) of the window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function getBounds() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-3',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getBounds.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.getBounds();\n\t     * }\n\t     *\n\t     * getBounds().then(bounds => console.log(bounds)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getBounds() {\n\t        return this.wire\n\t            .sendAction('get-window-bounds', this.identity)\n\t            .then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Centers the window on its current screen.\n\t     *\n\t     * @remarks Does not have an effect on minimized or maximized windows.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function centerWindow() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.center.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.center();\n\t     * }\n\t     *\n\t     * centerWindow().then(() => console.log('Window centered')).catch(err => console.log(err));\n\t     * ```\n\t     *\n\t     */\n\t    center() {\n\t        return this.wire.sendAction('center-window', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Removes focus from the window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function blurWindow() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.blur.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.blur();\n\t     * }\n\t     *\n\t     * blurWindow().then(() => console.log('Blured Window')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    blur() {\n\t        return this.wire.sendAction('blur-window', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Brings the window to the front of the window stack.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function BringWindowToFront() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.bringToFront.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.bringToFront();\n\t     * }\n\t     *\n\t     * BringWindowToFront().then(() => console.log('Window is in the front')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    bringToFront() {\n\t        return this.wire.sendAction('bring-window-to-front', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Performs the specified window transitions.\n\t     * @param transitions - Describes the animations to perform. See the tutorial.\n\t     * @param options - Options for the animation. See the tutorial.\n\t     *\n\t     * @example\n\t     * ```\n\t     * async function animateWindow() {\n\t     *     const transitions = {\n\t     *         opacity: {\n\t     *             opacity: 0.7,\n\t     *             duration: 500\n\t     *         },\n\t     *         position: {\n\t     *             top: 100,\n\t     *             left: 100,\n\t     *             duration: 500,\n\t     *             relative: true\n\t     *         }\n\t     *     };\n\t     *     const options = {\n\t     *         interrupt: true,\n\t     *         tween: 'ease-in'\n\t     *     };\n\t     *\n\t     *     const win = await fin.Window.getCurrent();\n\t     *     return win.animate(transitions, options);\n\t     * }\n\t     *\n\t     * animateWindow()\n\t     *     .then(() => console.log('Animation done'))\n\t     *     .catch(err => console.error(err));\n\t     * ```\n\t     */\n\t    animate(transitions, options) {\n\t        return this.wire\n\t            .sendAction('animate-window', {\n\t            transitions,\n\t            options,\n\t            ...this.identity\n\t        })\n\t            .then(() => undefined);\n\t    }\n\t    /**\n\t     * Hides the window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function hideWindow() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.hide.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.hide();\n\t     * }\n\t     *\n\t     * hideWindow().then(() => console.log('Window is hidden')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    hide() {\n\t        return this.wire.sendAction('hide-window', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * closes the window application\n\t     * @param force Close will be prevented from closing when force is false and\n\t     *  ‘close-requested’ has been subscribed to for application’s main window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function closeWindow() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-3',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.close.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.close();\n\t     * }\n\t     *\n\t     * closeWindow().then(() => console.log('Window closed')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    close(force = false) {\n\t        return this.wire.sendAction('close-window', { force, ...this.identity }).then(() => {\n\t            Object.setPrototypeOf(this, null);\n\t            return undefined;\n\t        });\n\t    }\n\t    focusedWebViewWasChanged() {\n\t        return this.wire.sendAction('focused-webview-changed', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Returns the native OS level Id.\n\t     *\n\t     * @remarks In Windows, it will return the Windows [handle](https://docs.microsoft.com/en-us/windows/desktop/WinProg/windows-data-types#HWND).\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function getWindowNativeId() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-3',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getNativeId.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.getNativeId();\n\t     * }\n\t     *\n\t     * getWindowNativeId().then(nativeId => console.log(nativeId)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getNativeId() {\n\t        return this.wire.sendAction('get-window-native-id', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Retrieves window's attached views.\n\t     * @experimental\n\t     *\n\t     * @example\n\t     * ```js\n\t     * const win = fin.Window.getCurrentSync();\n\t     *\n\t     * win.getCurrentViews()\n\t     *   .then(views => console.log(views))\n\t     *   .catch(console.error);\n\t     * ```\n\t     */\n\t    async getCurrentViews() {\n\t        const { payload } = await this.wire.sendAction('window-get-views', this.identity);\n\t        return payload.data.map((id) => new view_1.View(this.wire, id));\n\t    }\n\t    /**\n\t     * @deprecated Use {@link Window._Window.disableUserMovement} instead.\n\t     */\n\t    disableFrame() {\n\t        console.warn('Function is deprecated; use disableUserMovement instead.');\n\t        return this.wire.sendAction('disable-window-frame', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Prevents a user from changing a window's size/position when using the window's frame.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function disableUserMovement() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-3',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.disableFrame.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.disableUserMovement();\n\t     * }\n\t     *\n\t     * disableUserMovement().then(() => console.log('Window is disabled')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    disableUserMovement() {\n\t        return this.wire.sendAction('disable-window-frame', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * @deprecated Use {@link Window._Window.enableUserMovement} instead.\n\t     */\n\t    enableFrame() {\n\t        console.warn('Function is deprecated; use enableUserMovement instead.');\n\t        return this.wire.sendAction('enable-window-frame', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Re-enables user changes to a window's size/position when using the window's frame.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function enableUserMovement() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-3',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.enableFrame.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.enableUserMovement();\n\t     * }\n\t     *\n\t     * enableUserMovement().then(() => console.log('Window is enabled')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    enableUserMovement() {\n\t        return this.wire.sendAction('enable-window-frame', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Flashes the window’s frame and taskbar icon until stopFlashing is called or until a focus event is fired.\n\t     *\n\t     * @remarks On macOS flash only works on inactive windows.\n\t     * @example\n\t     * ```js\n\t     * async function windowFlash() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.flash.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.flash();\n\t     * }\n\t     *\n\t     * windowFlash().then(() => console.log('Window flashing')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    flash() {\n\t        return this.wire.sendAction('flash-window', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Stops the taskbar icon from flashing.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function stopWindowFlashing() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.stopFlashing.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.stopFlashing();\n\t     * }\n\t     *\n\t     * stopWindowFlashing().then(() => console.log('Application window flashing')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    stopFlashing() {\n\t        return this.wire.sendAction('stop-flash-window', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Gets an information object for the window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function getInfo() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getInfo.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.getInfo();\n\t     * }\n\t     *\n\t     * getInfo().then(info => console.log(info)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getInfo() {\n\t        return this.wire.sendAction('get-window-info', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Retrieves the window's Layout\n\t     *\n\t     * @example\n\t     * ```js\n\t     *     //get the current window\n\t     *     const window = await fin.Window.getCurrent();\n\t     *\n\t     *     //get the layout for the window\n\t     *     const layout = await window.getLayout();\n\t     * ```\n\t     * @experimental\n\t     */\n\t    async getLayout(layoutIdentity) {\n\t        this.wire.sendAction('window-get-layout', this.identity).catch((e) => {\n\t            // don't expose\n\t        });\n\t        const opts = await this.getOptions();\n\t        if (!opts.layout && !opts.layoutSnapshot) {\n\t            throw new Error('Window does not have a Layout');\n\t        }\n\t        return this.fin.Platform.Layout.wrap(layoutIdentity ?? this.identity);\n\t    }\n\t    /**\n\t     * Gets the current settings of the window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function getWindowOptions() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getOptions.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.getOptions();\n\t     * }\n\t     *\n\t     * getWindowOptions().then(opts => console.log(opts)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getOptions() {\n\t        return this.wire.sendAction('get-window-options', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Gets the parent application.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function getParentApplication() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getParentApplication.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.getParentApplication();\n\t     * }\n\t     *\n\t     * getParentApplication().then(parentApplication => console.log(parentApplication)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getParentApplication() {\n\t        this.wire.sendAction('window-get-parent-application', this.identity).catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return Promise.resolve(new application_1.Application(this.wire, this.identity));\n\t    }\n\t    /**\n\t     * Gets the parent window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function getParentWindow() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getParentWindow.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.getParentWindow();\n\t     * }\n\t     *\n\t     * getParentWindow().then(parentWindow => console.log(parentWindow)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getParentWindow() {\n\t        this.wire.sendAction('window-get-parent-window', this.identity).catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return Promise.resolve(new application_1.Application(this.wire, this.identity)).then((app) => app.getWindow());\n\t    }\n\t    /**\n\t     * ***DEPRECATED - please use Window.capturePage.***\n\t     * Gets a base64 encoded PNG image of the window or just part a of it.\n\t     * @param area The area of the window to be captured.\n\t     * Omitting it will capture the whole visible window.\n\t     *\n\t     * @tutorial Window.capturePage\n\t     */\n\t    async getSnapshot(area) {\n\t        const req = { area, ...this.identity };\n\t        console.warn('Window.getSnapshot has been deprecated, please use Window.capturePage');\n\t        const res = await this.wire.sendAction('get-window-snapshot', req);\n\t        return res.payload.data;\n\t    }\n\t    /**\n\t     * Gets the current state (\"minimized\", \"maximized\", or \"normal\") of the window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function getWindowState() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getState.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.getState();\n\t     * }\n\t     *\n\t     * getWindowState().then(winState => console.log(winState)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getState() {\n\t        return this.wire.sendAction('get-window-state', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Previously called getNativeWindow.\n\t     * Returns the [Window Object](https://developer.mozilla.org/en-US/docs/Web/API/Window)\n\t     * that represents the web context of the target window. This is the same object that\n\t     * you would get from calling [window.open()](https://developer.mozilla.org/en-US/docs/Web/API/Window/open) in a standard web context.\n\t     * The target window needs to be in the same application as the requesting window\n\t     * as well as comply with [same-origin](https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy) policy requirements.\n\t     *\n\t     * @example\n\t     * Injecting content into an empty window:\n\t     *\n\t     * ```js\n\t     * (async ()=> {\n\t     *     try {\n\t     *         const winName = `child-window-${Date.now()}`;\n\t     *         const win = await fin.Window.create({\n\t     *             name: winName,\n\t     *             url: 'about:blank'\n\t     *         });\n\t     *         win.getWebWindow().document.write('<h1>Hello World</h1>');\n\t     *     } catch (err) {\n\t     *         console.error(err);\n\t     *     }\n\t     * })();\n\t     * ```\n\t     *\n\t     * Cloning DOM elements from the parent window (in this example we clone an `h3` element from the parent window):\n\t     * ```js\n\t     * (async ()=> {\n\t     *     try {\n\t     *         const currentWindow = await fin.Window.getCurrent();\n\t     *         const parentWindow = await currentWindow.getParentWindow();\n\t     *         const clonedH3 = parentWindow.getWebWindow().document.querySelector('h3').cloneNode(true);\n\t     *         document.body.append(clonedH3);\n\t     *\n\t     *     } catch (err) {\n\t     *         console.error(err);\n\t     *     }\n\t     * })();\n\t     * ```\n\t     *\n\t     * Rendering on a child window via a library (in this example we are using the [lit-html](https://lit-html.polymer-project.org/)\n\t     * template library to render content on a blank child window. You are not going to be able to copy paste this example without\n\t     * configuring the project correctly but this would demonstrate some templating options available):\n\t     * ```js\n\t     * (async ()=> {\n\t     *     try {\n\t     *         const win = await fin.Window.create({\n\t     *             name: `child-window-${Date.now()}`,\n\t     *             url: 'about:blank'\n\t     *         });\n\t     *         const template = html`\n\t     *             <div>\n\t     *                 <span>Click here: </span>\n\t     *                 <button @click=${()=> console.log('Hello World!')}>log to the console</button>\n\t     *             </div>`;\n\t     *         render(template, win.getWebWindow().document.body);\n\t     *\n\t     *     } catch (err) {\n\t     *         console.error(err);\n\t     *     }\n\t     * })();\n\t     * ```\n\t     */\n\t    getWebWindow() {\n\t        this.wire.sendAction('window-get-web-window', this.identity).catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return this.wire.environment.getWebWindow(this.identity);\n\t    }\n\t    /**\n\t     * Determines if the window is a main window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * const wnd = fin.Window.getCurrentSync();\n\t     * const isMainWnd = wnd.isMainWindow();\n\t     * console.log('Is this a main window? ' + isMainWnd);\n\t     * ```\n\t     */\n\t    isMainWindow() {\n\t        this.wire.sendAction('window-is-main-window', this.identity).catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return this.me.uuid === this.me.name;\n\t    }\n\t    /**\n\t     * Determines if the window is currently showing.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function isWindowShowing() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.isShowing.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.isShowing();\n\t     * }\n\t     *\n\t     * isWindowShowing().then(bool => console.log(bool)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    isShowing() {\n\t        return this.wire.sendAction('is-window-showing', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Maximizes the window\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function maxWindow() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.maximize.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.maximize();\n\t     * }\n\t     *\n\t     * maxWindow().then(() => console.log('Maximized window')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    maximize() {\n\t        return this.wire.sendAction('maximize-window', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Minimizes the window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function minWindow() {\n\t     *     const win = await fin.Window.getCurrent();\n\t     *     return await win.minimize();\n\t     * }\n\t     *\n\t     * minWindow().then(() => console.log('Minimized window')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    minimize() {\n\t        return this.wire.sendAction('minimize-window', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Moves the window by a specified amount.\n\t     * @param deltaLeft The change in the left position of the window\n\t     * @param deltaTop The change in the top position of the window\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWin() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.moveBy.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     *\n\t     * async function moveBy(left, top) {\n\t     *     const win = await createWin();\n\t     *     return await win.moveBy(left, top);\n\t     * }\n\t     *\n\t     * moveBy(580, 300).then(() => console.log('Moved')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    moveBy(deltaLeft, deltaTop, positioningOptions) {\n\t        return this.wire\n\t            .sendAction('move-window-by', {\n\t            deltaLeft,\n\t            deltaTop,\n\t            positioningOptions,\n\t            ...this.identity\n\t        })\n\t            .then(() => undefined);\n\t    }\n\t    /**\n\t     * Moves the window to a specified location.\n\t     * @param left The left position of the window\n\t     * @param top The top position of the window\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWin() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.moveTo.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     *\n\t     * async function moveTo(left, top) {\n\t     *     const win = await createWin();\n\t     *     return await win.moveTo(left, top)\n\t     * }\n\t     *\n\t     * moveTo(580, 300).then(() => console.log('Moved')).catch(err => console.log(err))\n\t     * ```\n\t     */\n\t    moveTo(left, top, positioningOptions) {\n\t        return this.wire\n\t            .sendAction('move-window', {\n\t            left,\n\t            top,\n\t            positioningOptions,\n\t            ...this.identity\n\t        })\n\t            .then(() => undefined);\n\t    }\n\t    /**\n\t     * Resizes the window by a specified amount.\n\t     * @param deltaWidth The change in the width of the window\n\t     * @param deltaHeight The change in the height of the window\n\t     * @param anchor Specifies a corner to remain fixed during the resize.\n\t     * Can take the values: \"top-left\", \"top-right\", \"bottom-left\", or \"bottom-right\".\n\t     * If undefined, the default is \"top-left\"\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWin() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.resizeBy.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     *\n\t     * async function resizeBy(left, top, anchor) {\n\t     *     const win = await createWin();\n\t     *     return await win.resizeBy(left, top, anchor)\n\t     * }\n\t     *\n\t     * resizeBy(580, 300, 'top-right').then(() => console.log('Resized')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    resizeBy(deltaWidth, deltaHeight, anchor, positioningOptions) {\n\t        return this.wire\n\t            .sendAction('resize-window-by', {\n\t            deltaWidth: Math.floor(deltaWidth),\n\t            deltaHeight: Math.floor(deltaHeight),\n\t            anchor,\n\t            positioningOptions,\n\t            ...this.identity\n\t        })\n\t            .then(() => undefined);\n\t    }\n\t    /**\n\t     * Resizes the window to the specified dimensions.\n\t     * @param width The change in the width of the window\n\t     * @param height The change in the height of the window\n\t     * @param anchor Specifies a corner to remain fixed during the resize.\n\t     * Can take the values: \"top-left\", \"top-right\", \"bottom-left\", or \"bottom-right\".\n\t     * If undefined, the default is \"top-left\"\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWin() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.resizeTo.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     *\n\t     * async function resizeTo(left, top, anchor) {\n\t     *     const win = await createWin();\n\t     *     return await win.resizeTo(left, top, anchor);\n\t     * }\n\t     *\n\t     * resizeTo(580, 300, 'top-left').then(() => console.log('Resized')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    resizeTo(width, height, anchor, positioningOptions) {\n\t        return this.wire\n\t            .sendAction('resize-window', {\n\t            width: Math.floor(width),\n\t            height: Math.floor(height),\n\t            anchor,\n\t            positioningOptions,\n\t            ...this.identity\n\t        })\n\t            .then(() => undefined);\n\t    }\n\t    /**\n\t     * Restores the window to its normal state (i.e., unminimized, unmaximized).\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWin() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.restore.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     *\n\t     * async function restore() {\n\t     *     const win = await createWin();\n\t     *     return await win.restore();\n\t     * }\n\t     *\n\t     * restore().then(() => console.log('Restored')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    restore() {\n\t        return this.wire.sendAction('restore-window', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Will bring the window to the front of the entire stack and give it focus.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWin() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.setAsForeground.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     *\n\t     * async function setAsForeground() {\n\t     *     const win = await createWin();\n\t     *     return await win.setAsForeground()\n\t     * }\n\t     *\n\t     * setAsForeground().then(() => console.log('In the foreground')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    setAsForeground() {\n\t        return this.wire.sendAction('set-foreground-window', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Sets the window's size and position.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWin() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.setBounds.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     *\n\t     * async function setBounds(bounds) {\n\t     *     const win = await createWin();\n\t     *     return await win.setBounds(bounds);\n\t     * }\n\t     *\n\t     * setBounds({\n\t     *     height: 100,\n\t     *     width: 200,\n\t     *     top: 400,\n\t     *     left: 400\n\t     * }).then(() => console.log('Bounds set to window')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    setBounds(bounds, positioningOptions) {\n\t        return this.wire\n\t            .sendAction('set-window-bounds', { ...bounds, ...this.identity, positioningOptions })\n\t            .then(() => undefined);\n\t    }\n\t    /**\n\t     * Shows the window if it is hidden.\n\t     * @param force Show will be prevented from showing when force is false and\n\t     *  ‘show-requested’ has been subscribed to for application’s main window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWin() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.show.html',\n\t     *         autoShow: false\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     *\n\t     * async function show() {\n\t     *     const win = await createWin();\n\t     *     return await win.show()\n\t     * }\n\t     *\n\t     * show().then(() => console.log('Showing')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    show(force = false) {\n\t        return this.wire.sendAction('show-window', { force, ...this.identity }).then(() => undefined);\n\t    }\n\t    /**\n\t     * Shows the window if it is hidden at the specified location.\n\t     *\n\t     * @param left The left position of the window in pixels\n\t     * @param top The top position of the window in pixels\n\t     * @param force Show will be prevented from closing when force is false and\n\t     * ‘show-requested’ has been subscribed to for application’s main window\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWin() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.showAt.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     *\n\t     * async function showAt(left, top) {\n\t     *     const win = await createWin();\n\t     *     return await win.showAt(left, top)\n\t     * }\n\t     *\n\t     * showAt(580, 300).then(() => console.log('Showing at')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    showAt(left, top, force = false) {\n\t        return this.wire\n\t            .sendAction('show-at-window', {\n\t            force,\n\t            left: Math.floor(left),\n\t            top: Math.floor(top),\n\t            ...this.identity\n\t        })\n\t            .then(() => undefined);\n\t    }\n\t    /**\n\t     * Shows the Chromium Developer Tools\n\t     *\n\t     * @tutorial Window.showDeveloperTools\n\t     */\n\t    /**\n\t     * Updates the window using the passed options.\n\t     *\n\t     * @remarks Values that are objects are deep-merged, overwriting only the values that are provided.\n\t     * @param options Changes a window's options that were defined upon creation. See tutorial\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function updateOptions() {\n\t     *     const win = await fin.Window.getCurrent();\n\t     *     return win.updateOptions({maxWidth: 100});\n\t     * }\n\t     * updateOptions().then(() => console.log('options is updated')).catch(err => console.error(err));\n\t     * ```\n\t     */\n\t    updateOptions(options) {\n\t        return this.wire.sendAction('update-window-options', { options, ...this.identity }).then(() => undefined);\n\t    }\n\t    /**\n\t     * Provides credentials to authentication requests\n\t     * @param userName userName to provide to the authentication challenge\n\t     * @param password password to provide to the authentication challenge\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.Application.wrap({uuid: 'OpenfinPOC'}).then(app => {\n\t     *     app.on('window-auth-requested', evt => {\n\t     *         let win = fin.Window.wrap({ uuid: evt.uuid, name: evt.name});\n\t     *         win.authenticate('userName', 'P@assw0rd').then(()=> console.log('authenticated')).catch(err => console.log(err));\n\t     *     });\n\t     * });\n\t     * ```\n\t     */\n\t    authenticate(userName, password) {\n\t        return this.wire\n\t            .sendAction('window-authenticate', { userName, password, ...this.identity })\n\t            .then(() => undefined);\n\t    }\n\t    /**\n\t     * Shows a menu on the window.\n\t     *\n\t     * @remarks Returns a promise that resolves when the user has either selected an item or closed the menu. (This may take longer than other apis).\n\t     * Resolves to an object with `{result: 'clicked', data }` where data is the data field on the menu item clicked, or `{result 'closed'}` when the user doesn't select anything.\n\t     * Calling this method will close previously opened menus.\n\t     * @experimental\n\t     * @param options\n\t     * @typeParam Data User-defined shape for data returned upon menu item click.  Should be a\n\t     * [union](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#union-types)\n\t     * of all possible data shapes for the entire menu, and the click handler should process\n\t     * these with a \"reducer\" pattern.\n\t     * @example\n\t     * This could be used to show a drop down menu over views in a platform window:\n\t     * ```js\n\t     * const template = [\n\t     *     {\n\t     *         label: 'Menu Item 1',\n\t     *         data: 'hello from item 1'\n\t     *     },\n\t     *     { type: 'separator' },\n\t     *     {\n\t     *         label: 'Menu Item 2',\n\t     *         type: 'checkbox',\n\t     *         checked: true,\n\t     *         data: 'The user clicked the checkbox'\n\t     *     },\n\t     *     {\n\t     *         label: 'see more',\n\t     *         enabled: false,\n\t     *         submenu: [\n\t     *             { label: 'submenu 1', data: 'hello from submenu' }\n\t     *         ]\n\t     *     }\n\t     * ]\n\t     * fin.me.showPopupMenu({ template }).then(r => {\n\t     *     if (r.result === 'closed') {\n\t     *         console.log('nothing happened');\n\t     *     } else {\n\t     *         console.log(r.data)\n\t     *     }\n\t     * })\n\t     * ```\n\t     *\n\t     * Overriding the built in context menu (note: that this can be done per element or document wide):\n\t     * ```js\n\t     * document.addEventListener('contextmenu', e => {\n\t     *     e.preventDefault();\n\t     *     const template = [\n\t     *         {\n\t     *             label: 'Menu Item 1',\n\t     *             data: 'hello from item 1'\n\t     *         },\n\t     *         { type: 'separator' },\n\t     *         {\n\t     *             label: 'Menu Item 2',\n\t     *             type: 'checkbox',\n\t     *             checked: true,\n\t     *             data: 'The user clicked the checkbox'\n\t     *         },\n\t     *         {\n\t     *             label: 'see more',\n\t     *             enabled: false,\n\t     *             submenu: [\n\t     *                 { label: 'submenu 1', data: 'hello from submenu' }\n\t     *             ]\n\t     *         }\n\t     *     ]\n\t     *     fin.me.showPopupMenu({ template, x: e.x, y: e.y }).then(r => {\n\t     *         if (r.result === 'closed') {\n\t     *             console.log('nothing happened');\n\t     *         } else {\n\t     *             console.log(r.data)\n\t     *         }\n\t     *     })\n\t     * })\n\t     * ```\n\t     */\n\t    async showPopupMenu(options) {\n\t        const { payload } = await this.wire.sendAction('show-popup-menu', { options, ...this.identity });\n\t        return payload.data;\n\t    }\n\t    /**\n\t     * Closes the window's popup menu, if one exists.\n\t     * @experimental\n\t     *\n\t     * @remarks Only one popup menu will ever be showing at a time. Calling `showPopupMenu` will automatically close\n\t     * any existing popup menu.\n\t     *\n\t     *\n\t     * @example\n\t     * This could be used to close a popup menu if the user's mouse leaves an element for example.\n\t     *\n\t     * ```js\n\t     * await fin.me.closePopupMenu();\n\t     * ```\n\t     */\n\t    async closePopupMenu() {\n\t        return this.wire.sendAction('close-popup-menu', { ...this.identity }).then(() => undefined);\n\t    }\n\t    /**\n\t     * Dispatch a result to the caller of `showPopupWindow`.\n\t     *\n\t     * @remarks If this window isn't currently being shown as a popup, this call will silently fail.\n\t     * @param data Serializable data to send to the caller window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * await fin.me.dispatchPopupResult({\n\t     *     foo: 'bar'\n\t     * });\n\t     * ```\n\t     */\n\t    async dispatchPopupResult(data) {\n\t        this.wire.sendAction('window-dispatch-popup-result', this.identity).catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        await this.wire.sendAction('dispatch-popup-result', { data, ...this.identity });\n\t    }\n\t    /**\n\t     * Prints the contents of the window.\n\t     *\n\t     * @param options Configuration for the print task.\n\t     * @remarks When `silent` is set to `true`, the API will pick the system's default printer if deviceName is empty\n\t     * and the default settings for printing.\n\t     *\n\t     * Use the CSS style `page-break-before: always;` to force print to a new page.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * const win = fin.Window.getCurrentSync();\n\t     *\n\t     * win.print({ silent: false, deviceName: 'system-printer-name' }).then(() => {\n\t     *     console.log('print call has been sent to the system');\n\t     * });\n\t     * ```\n\t     *\n\t     * If a window has embedded views, those views will not print by default.  To print a window's contents including embedded views,\n\t     * use the `content` option:\n\t     *\n\t     * ```js\n\t     * const win = fin.Window.getCurrentSync();\n\t     *\n\t     * // Print embedded views\n\t     * win.print({ content: 'views' });\n\t     *\n\t     * // Print screenshot of current window\n\t     * win.print({ content: 'screenshot' })\n\t     * ```\n\t     *\n\t     * When `content` is set to `views`, the embedded views in the platform window will be concatenated and printed as\n\t     * individual pages.  If `includeSelf` is set to `true`, the platform window itself will be printed as the first\n\t     * page - be aware that this page will *not* include the embedded views - it will only include the contents of\n\t     * the platform window itself (e.g. tab stacks), with blank spaces where the view contents would be embedded.\n\t     *\n\t     * Due to a known issue, view contents that are not visible at the time `print` is called will not appear when\n\t     * printing `contents: views`.  This includes views that are obscured behind other active UI elements.\n\t     *\n\t     * To print the views embedded in their page context, set `content` to `screenshot`.\n\t     */\n\t    async print(options = { content: 'self' }) {\n\t        switch (options.content) {\n\t            case undefined:\n\t            case 'self':\n\t                return super.print(options);\n\t            case 'screenshot':\n\t                return this.wire.sendAction('print-screenshot', this.identity).then(() => undefined);\n\t            case 'views':\n\t                return this.wire.sendAction('print-views', { ...this.identity, options }).then(() => undefined);\n\t            default:\n\t                return undefined;\n\t        }\n\t    }\n\t}\n\tInstance$7._Window = _Window;\n\treturn Instance$7;\n}\n\nvar hasRequiredFactory$1;\n\nfunction requireFactory$1 () {\n\tif (hasRequiredFactory$1) return Factory$8;\n\thasRequiredFactory$1 = 1;\n\tObject.defineProperty(Factory$8, \"__esModule\", { value: true });\n\tFactory$8._WindowModule = void 0;\n\tconst base_1 = base;\n\tconst validate_1 = validate;\n\tconst Instance_1 = requireInstance();\n\t/**\n\t * Static namespace for OpenFin API methods that interact with the {@link _Window} class, available under `fin.Window`.\n\t */\n\tclass _WindowModule extends base_1.Base {\n\t    /**\n\t     * Asynchronously returns an API handle for the given Window identity.\n\t     *\n\t     * @remarks Wrapping a Window identity that does not yet exist will *not* throw an error, and instead\n\t     * returns a stub object that cannot yet perform rendering tasks. This can be useful for plumbing eventing\n\t     * for a Window throughout its entire lifecycle.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWin() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.wrap.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     * createWin().then(() => fin.Window.wrap({ uuid: 'app-1', name: 'myApp' }))\n\t     * .then(win => console.log('wrapped window'))\n\t     * .catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    async wrap(identity) {\n\t        this.wire.sendAction('window-wrap').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const errorMsg = (0, validate_1.validateIdentity)(identity);\n\t        if (errorMsg) {\n\t            throw new Error(errorMsg);\n\t        }\n\t        return new Instance_1._Window(this.wire, identity);\n\t    }\n\t    /**\n\t     * Synchronously returns an API handle for the given Window identity.\n\t     *\n\t     * @remarks Wrapping a Window identity that does not yet exist will *not* throw an error, and instead\n\t     * returns a stub object that cannot yet perform rendering tasks. This can be useful for plumbing eventing\n\t     * for a Window throughout its entire lifecycle.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWin() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.wrapSync.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     * await createWin();\n\t     * let win = fin.Window.wrapSync({ uuid: 'app-1', name: 'myApp' });\n\t     * ```\n\t     */\n\t    wrapSync(identity) {\n\t        this.wire.sendAction('window-wrap-sync').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const errorMsg = (0, validate_1.validateIdentity)(identity);\n\t        if (errorMsg) {\n\t            throw new Error(errorMsg);\n\t        }\n\t        return new Instance_1._Window(this.wire, identity);\n\t    }\n\t    /**\n\t     * Creates a new Window.\n\t     * @param options - Window creation options\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWindow() {\n\t     *     const winOption = {\n\t     *         name:'child',\n\t     *         defaultWidth: 300,\n\t     *         defaultHeight: 300,\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.create.html',\n\t     *         frame: true,\n\t     *         autoShow: true\n\t     *     };\n\t     *     return await fin.Window.create(winOption);\n\t     * }\n\t     *\n\t     * createWindow().then(() => console.log('Window is created')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    create(options) {\n\t        this.wire.sendAction('create-window').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const win = new Instance_1._Window(this.wire, { uuid: this.me.uuid, name: options.name });\n\t        return win.createWindow(options);\n\t    }\n\t    /**\n\t     * Asynchronously returns a Window object that represents the current window\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.Window.getCurrent()\n\t     * .then(wnd => console.log('current window'))\n\t     * .catch(err => console.log(err));\n\t     *\n\t     * ```\n\t     */\n\t    getCurrent() {\n\t        this.wire.sendAction('get-current-window').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        if (!this.wire.me.isWindow) {\n\t            throw new Error('You are not in a Window context');\n\t        }\n\t        const { uuid, name } = this.wire.me;\n\t        return this.wrap({ uuid, name });\n\t    }\n\t    /**\n\t     * Synchronously returns a Window object that represents the current window\n\t     *\n\t     * @example\n\t     * ```js\n\t     * const wnd = fin.Window.getCurrentSync();\n\t     * const info = await wnd.getInfo();\n\t     * console.log(info);\n\t     *\n\t     * ```\n\t     */\n\t    getCurrentSync() {\n\t        this.wire.sendAction('get-current-window-sync').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        if (!this.wire.me.isWindow) {\n\t            throw new Error('You are not in a Window context');\n\t        }\n\t        const { uuid, name } = this.wire.me;\n\t        return this.wrapSync({ uuid, name });\n\t    }\n\t}\n\tFactory$8._WindowModule = _WindowModule;\n\treturn Factory$8;\n}\n\nvar hasRequiredWindow;\n\nfunction requireWindow () {\n\tif (hasRequiredWindow) return window$1;\n\thasRequiredWindow = 1;\n\t(function (exports) {\n\t\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t\t    if (k2 === undefined) k2 = k;\n\t\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t\t    }\n\t\t    Object.defineProperty(o, k2, desc);\n\t\t}) : (function(o, m, k, k2) {\n\t\t    if (k2 === undefined) k2 = k;\n\t\t    o[k2] = m[k];\n\t\t}));\n\t\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t\t};\n\t\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t\t/**\n\t\t * Entry points for the OpenFin `Window` API (`fin.Window`).\n\t\t *\n\t\t * * {@link _WindowModule} contains static members of the `Window` API, accessible through `fin.Window`.\n\t\t * * {@link _Window} describes an instance of an OpenFin Window, e.g. as returned by `fin.Window.getCurrent`.\n\t\t *\n\t\t * These are separate code entities, and are documented separately.  In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/32.114.76.10/index.html),\n\t\t * both of these were documented on the same page.\n\t\t *\n\t\t * Underscore prefixing of OpenFin types that alias DOM entities will be fixed in a future version.\n\t\t *\n\t\t * @packageDocumentation\n\t\t */\n\t\t__exportStar(requireFactory$1(), exports);\n\t\t__exportStar(requireInstance(), exports); \n\t} (window$1));\n\treturn window$1;\n}\n\n/**\n * Entry point for the OpenFin `System` API (`fin.System`).\n *\n * * {@link System} contains static members of the `System` API (available under `fin.System`)\n *\n * @packageDocumentation\n */\nObject.defineProperty(system, \"__esModule\", { value: true });\nsystem.System = void 0;\nconst base_1$i = base;\nconst transport_errors_1$1 = transportErrors;\nconst window_1 = requireWindow();\nconst events_1$6 = require$$0;\n/**\n * An object representing the core of OpenFin Runtime. Allows the developer\n * to perform system-level actions, such as accessing logs, viewing processes,\n * clearing the cache and exiting the runtime as well as listen to {@link OpenFin.SystemEvents system events}.\n *\n */\nclass System extends base_1$i.EmitterBase {\n    /**\n     * @internal\n     */\n    constructor(wire) {\n        super(wire, 'system');\n    }\n    sendExternalProcessRequest(action, options) {\n        return new Promise((resolve, reject) => {\n            const exitEventKey = 'external-process-exited';\n            let processUuid;\n            let exitPayload;\n            let externalProcessExitHandler;\n            let ofWindow;\n            if (typeof options.listener === 'function') {\n                externalProcessExitHandler = (payload) => {\n                    const data = payload || {};\n                    exitPayload = {\n                        topic: 'exited',\n                        uuid: data.processUuid || '',\n                        exitCode: data.exitCode || 0\n                    };\n                    if (processUuid === payload.processUuid) {\n                        options.listener(exitPayload);\n                        ofWindow.removeListener(exitEventKey, externalProcessExitHandler);\n                    }\n                };\n                // window constructor expects the name is not undefined\n                if (!this.wire.me.name) {\n                    this.wire.me.name = this.wire.me.uuid;\n                }\n                ofWindow = new window_1._Window(this.wire, this.wire.me);\n                ofWindow.on(exitEventKey, externalProcessExitHandler);\n            }\n            this.wire\n                .sendAction(action, options)\n                .then(({ payload }) => {\n                processUuid = payload.data.uuid;\n                resolve(payload.data);\n                if (exitPayload && processUuid === exitPayload.uuid) {\n                    options.listener(exitPayload);\n                    ofWindow.removeListener(exitEventKey, externalProcessExitHandler);\n                }\n            })\n                .catch((err) => {\n                if (ofWindow) {\n                    ofWindow.removeListener(exitEventKey, externalProcessExitHandler);\n                }\n                reject(err);\n            });\n        });\n    }\n    /**\n     * Returns the version of the runtime. The version contains the major, minor,\n     * build and revision numbers.\n     *\n     * @example\n     * ```js\n     * fin.System.getVersion().then(v => console.log(v)).catch(err => console.log(err));\n     * ```\n     */\n    getVersion() {\n        return this.wire.sendAction('get-version').then(({ payload }) => payload.data);\n    }\n    /**\n     * Clears cached data containing application resource\n     * files (images, HTML, JavaScript files), cookies, and items stored in the\n     * Local Storage.\n     * @param options - See below for details.\n     *\n     * @remarks For more information on the accepted options, see the following pages:\n     * * cache: browsing data cache for html files and images ([caching](https://developer.mozilla.org/en-US/docs/Web/HTTP/Caching))\n     * * cookies: browser [cookies](https://developer.mozilla.org/en-US/docs/Web/HTTP/Cookies)\n     * * localStorage: browser data that can be used across sessions ([local storage](https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage))\n     * * appcache: html5 [application cache](https://developer.mozilla.org/en-US/docs/Web/HTML/Using_the_application_cache)\n     * @example\n     * ```js\n     * const clearCacheOptions = {\n     *     appcache: true,\n     *     cache: true,\n     *     cookies: true,\n     *     localStorage: true\n     * };\n     * fin.System.clearCache(clearCacheOptions).then(() => console.log('Cache cleared')).catch(err => console.log(err));\n     * ```\n     *\n     */\n    clearCache(options) {\n        return this.wire.sendAction('clear-cache', options).then(() => undefined);\n    }\n    /**\n     * Clears all cached data when OpenFin Runtime exits.\n     *\n     * @example\n     * ```js\n     * fin.System.deleteCacheOnExit().then(() => console.log('Deleted Cache')).catch(err => console.log(err));\n     * ```\n     */\n    deleteCacheOnExit() {\n        return this.wire.sendAction('delete-cache-request').then(() => undefined);\n    }\n    /**\n     * Exits the Runtime.\n     *\n     * @example\n     * ```js\n     * fin.System.exit().then(() => console.log('exit')).catch(err => console.log(err));\n     * ```\n     */\n    exit() {\n        return this.wire.sendAction('exit-desktop').then(() => undefined);\n    }\n    /**\n     * Fetches a JSON manifest using the browser process and returns a Javascript object.\n     * @param manifestUrl The URL of the manifest to fetch.\n     *\n     * @example\n     * ```js\n     * const manifest = await fin.System.fetchManifest('https://www.path-to-manifest.com');\n     * console.log(manifest);\n     * ```\n     */\n    async fetchManifest(manifestUrl) {\n        const { payload: { data } } = await this.wire.sendAction('fetch-manifest', { manifestUrl });\n        return data;\n    }\n    /**\n     * Writes any unwritten cookies data to disk.\n     *\n     * @example\n     * ```js\n     * fin.System.flushCookieStore()\n     *     .then(() => console.log('success'))\n     *     .catch(err => console.error(err));\n     * ```\n     */\n    flushCookieStore() {\n        return this.wire.sendAction('flush-cookie-store').then(() => undefined);\n    }\n    /**\n     * Retrieves an array of data (name, ids, bounds) for all application windows.\n     *\n     * @example\n     * ```js\n     * fin.System.getAllWindows().then(wins => console.log(wins)).catch(err => console.log(err));\n     * ```\n     */\n    getAllWindows() {\n        return this.wire.sendAction('get-all-windows').then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves an array of data for all applications.\n     *\n     * @example\n     * ```js\n     * fin.System.getAllApplications().then(apps => console.log(apps)).catch(err => console.log(err));\n     * ```\n     */\n    getAllApplications() {\n        return this.wire.sendAction('get-all-applications').then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves the command line argument string that started OpenFin Runtime.\n     *\n     * @example\n     * ```js\n     * fin.System.getCommandLineArguments().then(args => console.log(args)).catch(err => console.log(err));\n     * ```\n     */\n    getCommandLineArguments() {\n        return this.wire.sendAction('get-command-line-arguments').then(({ payload }) => payload.data);\n    }\n    /**\n     * Get the current state of the crash reporter.\n     *\n     * @example\n     * ```js\n     * fin.System.getCrashReporterState().then(state => console.log(state)).catch(err => console.log(err));\n     * ```\n     */\n    async getCrashReporterState() {\n        const { payload: { data: { diagnosticMode, isRunning } } } = await this.wire.sendAction('get-crash-reporter-state');\n        console.warn('diagnosticMode property is deprecated. It will be removed in a future version');\n        return {\n            // diagnosticMode will be removed in a future version\n            diagnosticMode,\n            diagnosticsMode: diagnosticMode,\n            isRunning\n        };\n    }\n    /**\n     * Start the crash reporter if not already running.\n     * @param options - configure crash reporter\n     *\n     * @remarks You can optionally specify `diagnosticsMode` to have the logs sent to\n     * OpenFin on runtime close. (NOTE: `diagnosticsMode` will turn on verbose logging and disable the sandbox\n     * for newly launched renderer processes. See https://developers.openfin.co/of-docs/docs/debugging#diagnostics-mode for\n     * more details.)\n     *\n     * @example\n     * ```js\n     * fin.System.startCrashReporter({diagnosticsMode: true}).then(reporter => console.log(reporter)).catch(err => console.log(err));\n     * ```\n     */\n    async startCrashReporter(options) {\n        const opts = options;\n        const newOpts = { ...opts, diagnosticMode: opts.diagnosticsMode || opts.diagnosticMode };\n        const { payload: { data: { diagnosticMode, isRunning } } } = await this.wire.sendAction('start-crash-reporter', newOpts);\n        return {\n            // diagnosticMode will be removed in a future version\n            diagnosticMode,\n            diagnosticsMode: diagnosticMode,\n            isRunning\n        };\n    }\n    /**\n     * Returns a hex encoded hash of the machine id and the currently logged in user name.\n     * This is the recommended way to uniquely identify a user / machine combination.\n     *\n     * @remarks For Windows systems this is a sha256 hash of the machine ID set in the registry key:\n     * `HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Cryptography\\MachineGuid` and `USERNAME`.\n     *\n     * For OSX systems, a native-level call is used to get the machine ID.\n     *\n     * @example\n     * ```js\n     * fin.System.getUniqueUserId().then(id => console.log(id)).catch(err => console.log(err));\n     * ```\n     */\n    getUniqueUserId() {\n        return this.wire.sendAction('get-unique-user-id').then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves a frame info object for the uuid and name passed in\n     * @param uuid - The UUID of the target.\n     * @param name - The name of the target.\n     *\n     * @remarks The possible types are 'window', 'iframe', 'external connection' or 'unknown'.\n     * @example\n     * ```js\n     * const entityUuid = 'OpenfinPOC';\n     * const entityName = '40c74b5d-ed98-40f7-853f-e3d3c2699175';\n     * fin.System.getEntityInfo(entityUuid, entityName).then(info => console.log(info)).catch(err => console.log(err));\n     *\n     * // example info shape\n     * {\n     *     \"uuid\": \"OpenfinPOC\",\n     *     \"name\": \"40c74b5d-ed98-40f7-853f-e3d3c2699175\",\n     *     \"parent\": {\n     *         \"uuid\": \"OpenfinPOC\",\n     *         \"name\": \"OpenfinPOC\"\n     *     },\n     *     \"entityType\": \"iframe\"\n     * }\n     * ```\n     */\n    getEntityInfo(uuid, name) {\n        return this.wire.sendAction('get-entity-info', { uuid, name }).then(({ payload }) => payload.data);\n    }\n    /**\n     * Gets the value of a given environment variable on the computer on which the runtime is installed\n     *\n     * @example\n     * ```js\n     * fin.System.getEnvironmentVariable('HOME').then(env => console.log(env)).catch(err => console.log(err));\n     * ```\n     */\n    getEnvironmentVariable(envName) {\n        return this.wire\n            .sendAction('get-environment-variable', {\n            environmentVariables: envName\n        })\n            .then(({ payload }) => payload.data);\n    }\n    /**\n     * Get currently focused Window.\n     * If a View currently has focus, returns the identity of View's parent Window.\n     * Use {@link Window._Window#getFocusedContent Window.getFocusedContent} to directly access currently focused Window or View.\n     *\n     * @example\n     * ```js\n     * fin.System.getFocusedWindow().then(winInfo => console.log(winInfo)).catch(err => console.log(err));\n     * ```\n     */\n    getFocusedWindow() {\n        return this.wire.sendAction('get-focused-window').then(({ payload }) => payload.data);\n    }\n    /**\n     * Get currently focused content. Returns identity of entity with `entityType`.\n     *\n     * @example\n     * ```js\n     * fin.System.getFocusedContent().then(contentIdentity => console.log(contentIdentity)).catch(err => console.log(err));\n     * ```\n     */\n    getFocusedContent() {\n        return this.wire.sendAction('get-focused-content').then(({ payload }) => payload.data);\n    }\n    /**\n     * Returns information about the given app's certification status\n     *\n     * @example\n     * ```js\n     * const manifestUrl = \"http://localhost:1234/app.json\"\n     * try {\n     *     const certificationInfo = await fin.System.isAppCertified(manifestUrl);\n     * } catch(err) {\n     *     console.error(err)\n     * }\n     * ```\n     */\n    async isAppCertified(manifestUrl) {\n        const { payload: { data: { certifiedInfo } } } = await this.wire.sendAction('is-app-certified', { manifestUrl });\n        return certifiedInfo;\n    }\n    /**\n     * Returns an array of all the installed runtime versions in an object.\n     *\n     * @example\n     * ```js\n     * fin.System.getInstalledRuntimes().then(runtimes => console.log(runtimes)).catch(err => console.log(err));\n     * ```\n     */\n    // incompatible with standalone node process.\n    getInstalledRuntimes() {\n        return this.wire.sendAction('get-installed-runtimes').then(({ payload }) => payload.data.runtimes);\n    }\n    // incompatible with standalone node process.\n    async getInstalledApps() {\n        const { payload: { data: { installedApps } } } = await this.wire.sendAction('get-installed-apps');\n        return installedApps;\n    }\n    /**\n     * Retrieves the contents of the log with the specified filename.\n     * @param options A object that id defined by the GetLogRequestType interface\n     *\n     * @example\n     * ```js\n     * async function getLog() {\n     *     const logs = await fin.System.getLogList();\n     *     return await fin.System.getLog(logs[0]);\n     * }\n     *\n     * getLog().then(log => console.log(log)).catch(err => console.log(err));\n     * ```\n     */\n    getLog(options) {\n        return this.wire.sendAction('view-log', options).then(({ payload }) => payload.data);\n    }\n    /**\n     * Returns a unique identifier (UUID) provided by the machine.\n     *\n     * @example\n     * ```js\n     * fin.System.getMachineId().then(id => console.log(id)).catch(err => console.log(err));\n     * ```\n     */\n    getMachineId() {\n        return this.wire.sendAction('get-machine-id').then(({ payload }) => payload.data);\n    }\n    /**\n     * Returns the minimum (inclusive) logging level that is currently being written to the log.\n     *\n     * @example\n     * ```js\n     * fin.System.getMinLogLevel().then(level => console.log(level)).catch(err => console.log(err));\n     * ```\n     */\n    getMinLogLevel() {\n        return this.wire.sendAction('get-min-log-level').then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves an array containing information for each log file.\n     *\n     * @example\n     * ```js\n     * fin.System.getLogList().then(logList => console.log(logList)).catch(err => console.log(err));\n     * ```\n     */\n    getLogList() {\n        return this.wire.sendAction('list-logs').then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves an object that contains data about the monitor setup of the\n     * computer that the runtime is running on.\n     *\n     * @example\n     * ```js\n     * fin.System.getMonitorInfo().then(monitorInfo => console.log(monitorInfo)).catch(err => console.log(err));\n     * ```\n     */\n    getMonitorInfo() {\n        return this.wire.sendAction('get-monitor-info').then(({ payload }) => payload.data);\n    }\n    /**\n     * Returns the mouse in virtual screen coordinates (left, top).\n     *\n     * @example\n     * ```js\n     * fin.System.getMousePosition().then(mousePosition => console.log(mousePosition)).catch(err => console.log(err));\n     * ```\n     */\n    getMousePosition() {\n        return this.wire.sendAction('get-mouse-position').then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves an array of all of the runtime processes that are currently\n     * running. Each element in the array is an object containing the uuid\n     * and the name of the application to which the process belongs.\n     * @deprecated Please use our new set of process APIs:\n     * {@link Window._Window#getProcessInfo Window.getProcessInfo}\n     * {@link View.View#getProcessInfo View.getProcessInfo}\n     * {@link Application.Application#getProcessInfo Application.getProcessInfo}\n     * {@link System#getAllProcessInfo System.getAllProcessInfo}\n     *\n     * @example\n     * ```js\n     * fin.System.getProcessList().then(ProcessList => console.log(ProcessList)).catch(err => console.log(err));\n     * ```\n     */\n    getProcessList() {\n        // eslint-disable-next-line no-console\n        console.warn('System.getProcessList has been deprecated. Please consider using our new process APIs: Window.getProcessInfo, View.getProcessInfo, Application.getProcessInfo, System.getAllProcessInfo');\n        return this.wire.sendAction('process-snapshot').then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves all process information.\n     *\n     * @remarks This includes the browser process and every process associated to all entities (windows and views).\n     *\n     * @example\n     * ```js\n     * const allProcessInfo = await fin.System.getAllProcessInfo();\n     * ```\n     * @experimental\n     */\n    async getAllProcessInfo() {\n        const { payload: { data } } = await this.wire.sendAction('get-all-process-info', this.identity);\n        return data;\n    }\n    /**\n     * Retrieves the Proxy settings.\n     *\n     * @example\n     * ```js\n     * fin.System.getProxySettings().then(ProxySetting => console.log(ProxySetting)).catch(err => console.log(err));\n     *\n     * //This response has the following shape:\n     * {\n     *     config: {\n     *         proxyAddress: \"proxyAddress\", //the configured Proxy Address\n     *         proxyPort: 0, //the configured Proxy port\n     *         type: \"system\" //Proxy Type\n     *     },\n     *     system: {\n     *         autoConfigUrl: \"\",\n     *         bypass: \"\",\n     *         enabled: false,\n     *         proxy: \"\"\n     *     }\n     * }\n     * ```\n     */\n    getProxySettings() {\n        return this.wire.sendAction('get-proxy-settings').then(({ payload }) => payload.data);\n    }\n    /**\n     * Returns information about the running Runtime in an object.\n     *\n     * @example\n     * ```js\n     * fin.System.getRuntimeInfo().then(RuntimeInfo => console.log(RuntimeInfo)).catch(err => console.log(err));\n     * ```\n     */\n    getRuntimeInfo() {\n        return this.wire.sendAction('get-runtime-info').then(({ payload }) => payload.data);\n    }\n    /**\n     * Returns information about the running RVM in an object.\n     *\n     * @example\n     * ```js\n     * fin.System.getRvmInfo().then(RvmInfo => console.log(RvmInfo)).catch(err => console.log(err));\n     * ```\n     */\n    // incompatible with standalone node process.\n    getRvmInfo() {\n        return this.wire.sendAction('get-rvm-info').then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves general system information. If you need more detailed information about the\n     * OS and the currently logged in user, use `fin.System.getOSInfo()` instead.\n     *\n     * @example\n     * ```js\n     * fin.System.getHostSpecs().then(specs => console.log(specs)).catch(err => console.log(err));\n     * ```\n     */\n    getHostSpecs() {\n        return this.wire.sendAction('get-host-specs').then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves information about the OS and the currently logged in user.\n     *\n     * @example\n     * ```js\n     * fin.System.getOSInfo().then(specs => console.log(specs)).catch(err => console.log(err));\n     * ```\n     */\n    getOSInfo() {\n        return this.wire.sendAction('get-os-info').then(({ payload }) => payload.data);\n    }\n    /**\n     * Runs an executable or batch file. A path to the file must be included in options.\n     * <br> A uuid may be optionally provided. If not provided, OpenFin will create a uuid for the new process.\n     * <br> Note: This method is restricted by default and must be enabled via\n     * <a href=\"https://developers.openfin.co/docs/api-security\">API security settings</a>. Also, this api has an enhanced permission set to make it less dangerous. So application owners can only allow to launch the assets owned by the application, the enabled downloaded files or the restricted executables.\n     * @param options A object that is defined in the ExternalProcessRequestType interface\n     *\n     * @remarks If an unused UUID is provided in options, it will be used. If no UUID is provided, OpenFin will assign one.\n     * This api has an enhanced permission set to make it less dangerous. So application owners can only allow to launch the\n     * assets owned by the application, the enabled downloaded files or the restricted executables.\n     *\n     * **Note:** Since _appAssets_ relies on the RVM, which is missing on MAC_OS, 'alias' is not available. Instead provide\n     * the full path e.g. _/Applications/Calculator.app/Contents/MacOS/Calculator_.\n     *\n     * @example\n     * Basic Example:\n     * ```js\n     * fin.System.launchExternalProcess({\n     *     path: 'notepad',\n     *     arguments: '',\n     *     listener: function (result) {\n     *         console.log('the exit code', result.exitCode);\n     *     }\n     * }).then(processIdentity => {\n     *     console.log(processIdentity);\n     * }).catch(error => {\n     *     console.log(error);\n     * });\n     * ```\n     *\n     * Promise resolution:\n     *\n     * ```js\n     * //This response has the following shape:\n     * {\n     *     uuid: \"FB3E6E36-0976-4C2B-9A09-FB2E54D2F1BB\" // The mapped UUID which identifies the launched process\n     * }\n     * ```\n     *\n     * Listener callback:\n     * ```js\n     * //This response has the following shape:\n     * {\n     *     topic: \"exited\", // Or \"released\" on a call to releaseExternalProcess\n     *     uuid: \"FB3E6E36-0976-4C2B-9A09-FB2E54D2F1BB\", // The mapped UUID which identifies the launched process\n     *     exitCode: 0 // Process exit code\n     * }\n     * ```\n     *\n     * By specifying a lifetime, an external process can live as long the window/application that launched it or\n     * persist after the application exits. The default value is null, which is equivalent to 'persist', meaning\n     * the process lives on after the application exits:\n     *\n     * ```js\n     * fin.System.launchExternalProcess({\n     *     path: 'notepad',\n     *     arguments: '',\n     *     listener: (result) => {\n     *         console.log('the exit code', result.exitCode);\n     *     },\n     *     lifetime: 'window'\n     * }).then(processIdentity => {\n     *     console.log(processIdentity);\n     * }).catch(error => {\n     *     console.log(error);\n     * });\n     * ```\n     *\n     * Note: A process that exits when the window/application exits cannot be released via fin.desktop.System.releaseExternalProcess.\n     *\n     * By specifying a cwd, it will set current working directory when launching an external process:\n     *\n     * ```js\n     * fin.System.launchExternalProcess({\n     *     path: 'cmd.exe',\n     *     cwd: 'c:\\\\temp',\n     *     arguments: '',\n     *     listener: (result) => {\n     *         console.log('the exit code', result.exitCode);\n     *     }\n     * }).then(processIdentity => {\n     *     console.log(processIdentity);\n     * }).catch(error => {\n     *     console.log(error);\n     * });\n     * ```\n     *\n     * Example using an alias from app.json appAssets property:\n     *\n     * ```json\n     * \"appAssets\": [\n     *     {\n     *         \"src\": \"exe.zip\",\n     *         \"alias\": \"myApp\",\n     *         \"version\": \"4.12.8\",\n     *         \"target\": \"myApp.exe\",\n     *         \"args\": \"a b c d\"\n     *     },\n     * ]\n     * ```\n     *\n     * ```js\n     * //  When called, if no arguments are passed then the arguments (if any)\n     * //  are taken from the 'app.json' file, from the  'args' parameter\n     * //  of the 'appAssets' Object with the relevant 'alias'.\n     * fin.System.launchExternalProcess({\n     *     //Additionally note that the executable found in the zip file specified in appAssets\n     *     //will default to the one mentioned by appAssets.target\n     *     //If the the path below refers to a specific path it will override this default\n     *     alias: 'myApp',\n     *     listener: (result) => {\n     *         console.log('the exit code', result.exitCode);\n     *     }\n     * }).then(processIdentity => {\n     *     console.log(processIdentity);\n     * }).catch(error => {\n     *     console.log(error);\n     * });\n     * ```\n     *\n     * Example using an alias but overriding the arguments:\n     *\n     * ```json\n     * \"appAssets\": [\n     *     {\n     *         \"src\": \"exe.zip\",\n     *         \"alias\": \"myApp\",\n     *         \"version\": \"4.12.8\",\n     *         \"target\": \"myApp.exe\",\n     *         \"args\": \"a b c d\"\n     *     },\n     * ]\n     * ```\n     *\n     * ```js\n     * //  If 'arguments' is passed as a parameter it takes precedence\n     * //  over any 'args' set in the 'app.json'.\n     * fin.System.launchExternalProcess({\n     *     alias: 'myApp',\n     *     arguments: 'e f g',\n     *     listener: (result) => {\n     *         console.log('the exit code', result.exitCode);\n     *     }\n     * }).then(processIdentity => {\n     *     console.log(processIdentity);\n     * }).catch(error => {\n     *     console.log(error);\n     * });\n     * ```\n     *\n     * It is now possible to optionally perform any combination of the following certificate checks\n     * against an absolute target via `fin.desktop.System.launchExternalProcess()`:\n     *\n     * ```js\n     * \"certificate\": {\n     *     \"serial\": \"3c a5 ...\",                        // A hex string with or without spaces\n     *     \"subject\": \"O=OpenFin INC., L=New York, ...\", // An internally tokenized and comma delimited string allowing partial or full checks of the subject fields\n     *     \"publickey\": \"3c a5 ...\",                     // A hex string with or without spaces\n     *     \"thumbprint\": \"3c a5 ...\",                    // A hex string with or without spaces\n     *     \"trusted\": true                               // A boolean indicating that the certificate is trusted and not revoked\n     * }\n     * ```\n     *\n     * Providing this information as part of the default configurations for assets in an application's manifest\n     * will be added in a future RVM update:\n     *\n     * ```js\n     * fin.System.launchExternalProcess({\n     *     path: 'C:\\\\Users\\\\ExampleUser\\\\AppData\\\\Local\\\\OpenFin\\\\OpenFinRVM.exe',\n     *     arguments: '--version',\n     *     certificate: {\n     *         trusted: true,\n     *         subject: 'O=OpenFin INC., L=New York, S=NY, C=US',\n     *         thumbprint: '‎3c a5 28 19 83 05 fe 69 88 e6 8f 4b 3a af c5 c5 1b 07 80 5b'\n     *     },\n     *     listener: (result) => {\n     *         console.log('the exit code', result.exitCode);\n     *     }\n     * }).then(processIdentity => {\n     *     console.log(processIdentity);\n     * }).catch(error => {\n     *     console.log(error);\n     * });\n     * ```\n     *\n     * It is possible to launch files that have been downloaded by the user by listening to the window\n     * `file-download-completed` event and using the `fileUuid` provided by the event:\n     *\n     * ```js\n     * const win = fin.Window.getCurrentSync();\n     * win.addListener('file-download-completed', (evt) => {\n     *     if (evt.state === 'completed') {\n     *         fin.System.launchExternalProcess({\n     *             fileUuid: evt.fileUuid,\n     *             arguments: '',\n     *             listener: (result) => {\n     *                 console.log('the exit code', result.exitCode);\n     *             }\n     *         }).then(processIdentity => {\n     *             console.log(processIdentity);\n     *         }).catch(error => {\n     *             console.log(error);\n     *         });\n     *     }\n     * });\n     * ```\n     *\n     * Launching assets specified in the app manifest:\n     *\n     * Sample appAssets section in app.json\n     * ```js\n     *     \"appAssets\": [\n     *         {\n     *             \"src\": \"http://filesamples.com/exe.zip\",\n     *             \"alias\": \"myApp\",\n     *             \"version\": \"4.12.8\",\n     *             \"target\": \"myApp.exe\",\n     *             \"args\": \"a b c d\"\n     *         },\n     *         {\n     *             \"src\": \"http://examples.com/exe.zip\",\n     *             \"alias\": \"myApp2\",\n     *             \"version\": \"5.12.8\",\n     *             \"target\": \"myApp2.exe\",\n     *             \"args\": \"a b c\"\n     *         }\n     *     ]\n     * ```\n     *\n     * This permission allows for launching of all assets specified in the above appAssets section. (\"myApp\" and \"myApp2\"):\n     *\n     * ```js\n     *     \"permissions\": {\n     *        \"System\": {\n     *            \"launchExternalProcess\": {\n     *                 \"enabled\": true,\n     *                 \"assets\": {\n     *                     \"enabled\": true\n     *                 }\n     *             }\n     *        }\n     *     }\n     * ```\n     *\n     * This permission allows for launching of _only_ the \"myApp\" asset in the above appAssets section, as defined in `srcRules`:\n     * ```js\n     *     \"permissions\": {\n     *        \"System\": {\n     *            \"launchExternalProcess\": {\n     *                 \"enabled\": true,\n     *                 \"assets\": {\n     *                     \"enabled\": true\n     *                     \"srcRules\": [\n     *                         {\n     *                             \"match\": [\n     *                                 \"*://filesamples.com/*\"\n     *                             ],\n     *                             \"behavior\": \"allow\"\n     *                         },\n     *                         {\n     *                             \"match\": [\n     *                                 \"<all_urls>\"\n     *                             ],\n     *                             \"behavior\": \"block\"\n     *                         }\n     *                     ]\n     *                 }\n     *             }\n     *        }\n     *     }\n     * ```\n     *\n     * Launching downloaded files:\n     * ```js\n     *     \"permissions\": {\n     *        \"System\": {\n     *            \"launchExternalProcess\": {\n     *                 \"enabled\": true,\n     *                 \"downloads\": {\n     *                     \"enabled\": true\n     *                 }\n     *             }\n     *        }\n     *     }\n     * ```\n     *\n     * This permission allows to launch all the executables:\n     * ```js\n     *     \"permissions\": {\n     *        \"System\": {\n     *            \"launchExternalProcess\": {\n     *                 \"enabled\": true,\n     *                 \"executables\": {\n     *                     \"enabled\": true\n     *                 }\n     *             }\n     *        }\n     *     }\n     * ```\n     *\n     *\n     * This permission only allows launching of executables whose file paths match the corresponding `pathRules`:\n     * ```js\n     *     \"permissions\": {\n     *        \"System\": {\n     *            \"launchExternalProcess\": {\n     *                 \"enabled\": true,\n     *                 \"executables\": {\n     *                     \"enabled\": true\n     *                     \"pathRules\": [\n     *                         {\n     *                             \"match\": [\n     *                                 \"/Windows/System32/*.exe\"\n     *                             ],\n     *                             \"behavior\": \"allow\"\n     *                         },\n     *                         {\n     *                             \"match\": [\n     *                                 \"*.exe\"\n     *                             ],\n     *                             \"behavior\": \"block\"\n     *                         }\n     *                     ]\n     *                 }\n     *             }\n     *        }\n     *     }\n     * ```\n     */\n    launchExternalProcess(options) {\n        return this.sendExternalProcessRequest('launch-external-process', options);\n    }\n    /**\n     * Monitors a running process. A pid for the process must be included in options.\n     * <br> A uuid may be optionally provided. If not provided, OpenFin will create a uuid for the new process.\n     *\n     * @remarks If an unused uuid is provided in options, it will be used. If no uuid is provided, OpefinFin will assign a uuid.\n     * @example\n     * ```js\n     * fin.System.monitorExternalProcess({\n     *     pid: 10208,\n     *     uuid: 'my-external-process', // optional\n     *     listener: function (result) {\n     *         console.log('the exit code', result.exitCode);\n     *     }\n     * }).then(processIdentity => console.log(processIdentity)).catch(err => console.log(err));\n     * ```\n     */\n    monitorExternalProcess(options) {\n        return this.sendExternalProcessRequest('monitor-external-process', options);\n    }\n    /**\n     * Writes the passed message into both the log file and the console.\n     * @param level The log level for the entry. Can be either \"info\", \"warning\" or \"error\"\n     * @param message The log message text\n     *\n     * @example\n     * ```js\n     * fin.System.log(\"info\", \"An example log message\").then(() => console.log('Log info message')).catch(err => console.log(err));\n     * ```\n     */\n    log(level, message) {\n        return this.wire.sendAction('write-to-log', { level, message }).then(() => undefined);\n    }\n    /**\n     * Opens the passed URL in the default web browser.\n     *\n     * @remarks It only supports http(s) and fin(s) protocols by default.\n     * In order to use other custom protocols, they have to be enabled via\n     * [API security settings](https://developers.openfin.co/docs/api-security).\n     * File protocol and file path are not supported.\n     * @param url The URL to open\n     *\n     * @example\n     * ```js\n     * fin.System.openUrlWithBrowser('https://cdn.openfin.co/docs/javascript/stable/tutorial-System.openUrlWithBrowser.html')\n     * .then(() => console.log('Opened URL'))\n     * .catch(err => console.log(err));\n     * ```\n     *\n     * Example of permission definition to enable non-default protocols:\n     *\n     * Note: permission definition should be specified in an app manifest file if there is no DOS settings.\n     * Otherwise it has to be specified in both DOS and app manifest files.\n     *\n     * ```js\n     *     \"permissions\": {\n     *        \"System\": {\n     *            \"openUrlWithBrowser\": {\n     *                 \"enabled\": true,\n     *                 \"protocols\": [ \"msteams\", \"slack\"]\n     *             }\n     *        }\n     *     }\n     * ```\n     */\n    openUrlWithBrowser(url) {\n        return this.wire.sendAction('open-url-with-browser', { url }).then(() => undefined);\n    }\n    /**\n     * Creates a new registry entry under the HKCU root Windows registry key if the given custom protocol name doesn't exist or\n     * overwrites the existing registry entry if the given custom protocol name already exists.\n     *\n     * Note: This method is restricted by default and must be enabled via\n     * {@link https://developers.openfin.co/docs/api-security API security settings}. It requires RVM 12 or higher version.\n     *\n     *\n     * @remarks These protocols are reserved and cannot be registered:\n     * - fin\n     * - fins\n     * - openfin\n     * - URI Schemes registered with {@link https://en.wikipedia.org/wiki/List_of_URI_schemes#Official_IANA-registered_schemes IANA}\n     *\n     * @throws if a given custom protocol failed to be registered.\n     * @throws if a manifest URL contains the '%1' string.\n     * @throws if a manifest URL contains a query string parameter which name equals to the Protocol Launch Request Parameter Name.\n     * @throws if the full length of the command string that is to be written to the registry exceeds 2048 bytes.\n     *\n     * @example\n     * ```js\n     * fin.System.registerCustomProtocol({protocolName:'protocol1'}).then(console.log).catch(console.error);\n     * ```\n     */\n    async registerCustomProtocol(options) {\n        if (typeof options !== 'object') {\n            throw new Error('Must provide an object with a `protocolName` property having a string value.');\n        }\n        await this.wire.sendAction('register-custom-protocol', options);\n    }\n    /**\n     * Removes the registry entry for a given custom protocol.\n     *\n     * Note: This method is restricted by default and must be enabled via\n     * {@link https://developers.openfin.co/docs/api-security API security settings}. It requires RVM 12 or higher version.\n     *\n     *\n     * @remarks These protocols are reserved and cannot be unregistered:\n     * - fin\n     * - fins\n     * - openfin\n     * - URI Schemes registered with {@link https://en.wikipedia.org/wiki/List_of_URI_schemes#Official_IANA-registered_schemes IANA}\n     *\n     * @throws if a protocol entry failed to be removed in registry.\n     *\n     * @example\n     * ```js\n     * await fin.System.unregisterCustomProtocol('protocol1');\n     * ```\n     */\n    async unregisterCustomProtocol(protocolName) {\n        await this.wire.sendAction('unregister-custom-protocol', { protocolName });\n    }\n    /**\n     * Retrieves the registration state for a given custom protocol.\n     *\n     * Note: This method is restricted by default and must be enabled via\n     * {@link https://developers.openfin.co/docs/api-security API security settings}. It requires RVM 12 or higher version.\n     *\n     * @remarks These protocols are reserved and cannot get states for them:\n     * - fin\n     * - fins\n     * - openfin\n     * - URI Schemes registered with {@link https://en.wikipedia.org/wiki/List_of_URI_schemes#Official_IANA-registered_schemes IANA}\n     *\n     *\n     * @example\n     * ```js\n     * const protocolState = await fin.System.getCustomProtocolState('protocol1');\n     */\n    async getCustomProtocolState(protocolName) {\n        return this.wire.sendAction('get-custom-protocol-state', { protocolName }).then(({ payload }) => payload.data);\n    }\n    /**\n     * Removes the process entry for the passed UUID obtained from a prior call\n     * of fin.System.launchExternalProcess().\n     * @param uuid The UUID for a process obtained from a prior call to fin.desktop.System.launchExternalProcess()\n     *\n     * @example\n     * ```js\n     * fin.System.launchExternalProcess({\n     *     path: \"notepad\",\n     *     listener: function (result) {\n     *         console.log(\"The exit code\", result.exitCode);\n     *     }\n     * })\n     * .then(identity => fin.System.releaseExternalProcess(identity.uuid))\n     * .then(() => console.log('Process has been unmapped!'))\n     * .catch(err => console.log(err));\n     * ```\n     */\n    releaseExternalProcess(uuid) {\n        return this.wire.sendAction('release-external-process', { uuid }).then(() => undefined);\n    }\n    /**\n     * Shows the Chromium Developer Tools for the specified window\n     * @param identity This is a object that is defined by the Identity interface\n     *\n     * @tutorial System.showDeveloperTools\n     */\n    showDeveloperTools(identity) {\n        return this.wire.sendAction('show-developer-tools', identity).then(() => undefined);\n    }\n    /**\n     * Attempt to close an external process. The process will be terminated if it\n     * has not closed after the elapsed timeout in milliseconds.\n     *\n     * Note: This method is restricted by default and must be enabled via\n     * <a href=\"https://developers.openfin.co/docs/api-security\">API security settings</a>.\n     * @param options A object defined in the TerminateExternalRequestType interface\n     *\n     * @example\n     * ```js\n     * fin.System.launchExternalProcess({\n     *     path: \"notepad\",\n     *     listener: function (result) {\n     *         console.log(\"The exit code\", result.exitCode);\n     *     }\n     * })\n     * .then(identity => fin.System.terminateExternalProcess({uuid: identity.uuid, timeout:2000, killTree: false}))\n     * .then(() => console.log('Terminate the process'))\n     * .catch(err => console.log(err));\n     * ```\n     */\n    terminateExternalProcess(options) {\n        return this.wire.sendAction('terminate-external-process', options).then(() => undefined);\n    }\n    /**\n     * Update the OpenFin Runtime Proxy settings.\n     * @param options A config object defined in the ProxyConfig interface\n     *\n     * @example\n     * ```js\n     * fin.System.updateProxySettings({proxyAddress:'127.0.0.1', proxyPort:8080, type:'http'})\n     * .then(() => console.log('Update proxy successfully'))\n     * .catch(err => console.error(err));\n     * ```\n     */\n    updateProxySettings(options) {\n        return this.wire.sendAction('update-proxy', options).then(() => undefined);\n    }\n    /**\n     * Downloads the given application asset.\n     *\n     * Note: This method is restricted by default and must be enabled via\n     * <a href=\"https://developers.openfin.co/docs/api-security\">API security settings</a>.\n     * @param appAsset App asset object\n     *\n     * @example\n     * ```js\n     * async function downloadAsset() {\n     *     const appAsset = {\n     *         src: `${ location.origin }/assets.zip`,\n     *         alias: 'dirApp',\n     *         version: '1.23.24',\n     *         target: 'assets/run.bat'\n     *     };\n     *\n     *     return fin.System.downloadAsset(appAsset, (progress => {\n     *     //Print progress as we download the asset.\n     *         const downloadedPercent = Math.floor((progress.downloadedBytes / progress.totalBytes) * 100);\n     *         console.log(`Downloaded ${downloadedPercent}%`);\n     *     }));\n     * }\n     *\n     * downloadAsset()\n     * .then(() => console.log('Success'))\n     * .catch(err => console.error(err));\n     *\n     * ```\n     */\n    // incompatible with standalone node process.\n    async downloadAsset(appAsset, progressListener) {\n        // eslint-disable-next-line @typescript-eslint/explicit-function-return-type, @typescript-eslint/no-empty-function\n        const noop = () => { };\n        let resolve = noop;\n        let reject = noop;\n        const downloadCompletePromise = new Promise((y, n) => {\n            resolve = y;\n            reject = n;\n        });\n        // node.js environment not supported\n        if (this.wire.environment.type !== 'openfin') {\n            throw new transport_errors_1$1.NotSupportedError('downloadAsset only supported in an OpenFin Render process');\n        }\n        const callSite = transport_errors_1$1.RuntimeError.getCallSite();\n        const downloadId = this.wire.environment.getNextMessageId().toString();\n        const dlProgressKey = `asset-download-progress-${downloadId}`;\n        const dlErrorKey = `asset-download-error-${downloadId}`;\n        const dlCompleteKey = `asset-download-complete-${downloadId}`;\n        const dlProgress = (progress) => {\n            const p = {\n                downloadedBytes: progress.downloadedBytes,\n                totalBytes: progress.totalBytes\n            };\n            progressListener(p);\n        };\n        const cleanListeners = () => {\n            // TODO: fix internal types\n            // @ts-expect-error\n            this.removeListener(dlProgressKey, dlProgress);\n        };\n        const dlError = (payload) => {\n            cleanListeners();\n            const { reason, err: error } = payload;\n            reject(new transport_errors_1$1.RuntimeError({ reason, error }, callSite));\n        };\n        const dlComplete = () => {\n            cleanListeners();\n            resolve();\n        };\n        await Promise.all([\n            // TODO: fix internal types\n            // @ts-expect-error\n            this.on(dlProgressKey, dlProgress),\n            // TODO: fix internal types\n            // @ts-expect-error\n            this.once(dlErrorKey, dlError),\n            // TODO: fix internal types\n            // @ts-expect-error\n            this.once(dlCompleteKey, dlComplete)\n        ]);\n        const downloadOptions = Object.assign(appAsset, { downloadId });\n        await this.wire.sendAction('download-asset', downloadOptions).catch((err) => {\n            cleanListeners();\n            throw err;\n        });\n        return downloadCompletePromise;\n    }\n    /**\n     * Downloads a version of the runtime.\n     * @param options - Download options.\n     * @param progressListener - called as the runtime is downloaded with progress information.\n     *\n     * @remarks Only supported in an OpenFin Render process.\n     *\n     * @example\n     * ```js\n     * var downloadOptions = {\n     *     //Specific version number required, if given a release channel the call will produce an error.\n     *     version: '9.61.30.1'\n     * };\n     *\n     * function onProgress(progress) {\n     *     console.log(`${Math.floor((progress.downloadedBytes / progress.totalBytes) * 100)}%`);\n     * }\n     *\n     * fin.System.downloadRuntime(downloadOptions, onProgress).then(() => {\n     *     console.log('Download complete');\n     * }).catch(err =>    {\n     *     console.log(`Download Failed, we could retry: ${err.message}`);\n     *     console.log(err);\n     * });\n     * ```\n     */\n    downloadRuntime(options, progressListener) {\n        const callsites = transport_errors_1$1.RuntimeError.getCallSite();\n        return new Promise((resolve, reject) => {\n            // node.js environment not supported\n            if (this.wire.environment.type !== 'openfin') {\n                reject(new transport_errors_1$1.NotSupportedError('downloadRuntime only supported in an OpenFin Render process'));\n                return;\n            }\n            const downloadId = this.wire.environment.getNextMessageId().toString();\n            const dlProgressKey = `runtime-download-progress-${downloadId}`;\n            const dlErrorKey = `runtime-download-error-${downloadId}`;\n            const dlCompleteKey = `runtime-download-complete-${downloadId}`;\n            const dlProgress = (progress) => {\n                const p = {\n                    downloadedBytes: progress.downloadedBytes,\n                    totalBytes: progress.totalBytes\n                };\n                progressListener(p);\n            };\n            const cleanListeners = () => {\n                // TODO: fix internal types\n                // @ts-expect-error\n                this.removeListener(dlProgressKey, dlProgress);\n            };\n            const dlError = (payload) => {\n                cleanListeners();\n                const { reason, err: error } = payload;\n                reject(new transport_errors_1$1.RuntimeError({ reason, error }, callsites));\n            };\n            const dlComplete = () => {\n                cleanListeners();\n                resolve();\n            };\n            // TODO: fix internal types\n            // @ts-expect-error\n            this.on(dlProgressKey, dlProgress);\n            // TODO: fix internal types\n            // @ts-expect-error\n            this.once(dlErrorKey, dlError);\n            // TODO: fix internal types\n            // @ts-expect-error\n            this.once(dlCompleteKey, dlComplete);\n            const downloadOptions = Object.assign(options, { downloadId });\n            this.wire.sendAction('download-runtime', downloadOptions).catch((err) => {\n                cleanListeners();\n                reject(err);\n            });\n        });\n    }\n    /**\n     * Download preload scripts from given URLs\n     * @param scripts - URLs of preload scripts.\n     *\n     * @example\n     * ```js\n     * const scripts = [\n     *     { url: 'http://.../preload.js' },\n     *     { url: 'http://.../preload2.js' }\n     * ];\n     *\n     * fin.System.downloadPreloadScripts(scripts).then(results => {\n     *     results.forEach(({url, success, error}) => {\n     *         console.log(`URL: ${url}`);\n     *         console.log(`Success: ${success}`);\n     *         if (error) {\n     *             console.log(`Error: ${error}`);\n     *         }\n     *     });\n     * });\n     * ```\n     */\n    downloadPreloadScripts(scripts) {\n        return this.wire.sendAction('download-preload-scripts', { scripts }).then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves an array of data (name, ids, bounds) for all application windows.\n     *\n     * @example\n     * ```js\n     * fin.System.getAllExternalApplications()\n     * .then(externalApps => console.log('Total external apps: ' + externalApps.length))\n     * .catch(err => console.log(err));\n     * ```\n     */\n    getAllExternalApplications() {\n        return this.wire.sendAction('get-all-external-applications').then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves app asset information.\n     * @param options\n     *\n     * @example\n     * ```js\n     * fin.System.getAppAssetInfo({alias:'procexp'}).then(assetInfo => console.log(assetInfo)).catch(err => console.log(err));\n     * ```\n     */\n    getAppAssetInfo(options) {\n        return this.wire.sendAction('get-app-asset-info', options).then(({ payload }) => payload.data);\n    }\n    /**\n     * Get additional info of cookies.\n     *\n     * @example\n     * ```js\n     * fin.System.getCookies({name: 'myCookie'}).then(cookies => console.log(cookies)).catch(err => console.log(err));\n     * ```\n     */\n    getCookies(options) {\n        const url = this.wire.environment.getUrl();\n        const newOptions = Object.assign(options, { url });\n        return this.wire.sendAction('get-cookies', newOptions).then(({ payload }) => payload.data);\n    }\n    /**\n     * Set the minimum log level above which logs will be written to the OpenFin log\n     * @param The minimum level (inclusive) above which all calls to log will be written\n     *\n     * @example\n     * ```js\n     * fin.System.setMinLogLevel(\"verbose\").then(() => console.log(\"log level is set to verbose\")).catch(err => console.log(err));\n     * ```\n     */\n    setMinLogLevel(level) {\n        return this.wire.sendAction('set-min-log-level', { level }).then(() => undefined);\n    }\n    /**\n     * Retrieves the UUID of the computer on which the runtime is installed\n     * @param uuid The uuid of the running application\n     *\n     * @example\n     * ```js\n     * fin.System.resolveUuid('OpenfinPOC').then(entity => console.log(entity)).catch(err => console.log(err));\n     * ```\n     */\n    resolveUuid(uuid) {\n        return this.wire\n            .sendAction('resolve-uuid', {\n            entityKey: uuid\n        })\n            .then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves an array of data for all external applications\n     * @param requestingIdentity This object is described in the Identity typedef\n     * @param data Any data type to pass to the method\n     *\n     * @ignore\n     */\n    executeOnRemote(requestingIdentity, data) {\n        data.requestingIdentity = requestingIdentity;\n        return this.wire.ferryAction(data);\n    }\n    /**\n     * Reads the specifed value from the registry.\n     * @remarks This method is restricted by default and must be enabled via\n     * [API security settings](https://developers.openfin.co/docs/api-security).\n     * @param rootKey - The registry root key.\n     * @param subkey - The registry key.\n     * @param value - The registry value name.\n     *\n     * @example\n     * ```js\n     * fin.System.readRegistryValue(\"HKEY_LOCAL_MACHINE\", \"HARDWARE\\\\DESCRIPTION\\\\System\", \"BootArchitecture\").then(val => console.log(val)).catch(err => console.log(err));\n     * ```\n     *\n     * See {@link https://msdn.microsoft.com/en-us/library/windows/desktop/ms681382(v=vs.85).aspx here} for Window's error code definitions.\n     *\n     * Example payloads of different registry types:\n     *\n     * See list of types {@link https://msdn.microsoft.com/en-us/library/windows/desktop/ms724884(v=vs.85).aspx here}.\n     *\n     * ```js\n     * // REG_DWORD\n     * {\n     *     data: 1,\n     *     rootKey: \"HKEY_LOCAL_MACHINE\",\n     *     subkey: \"Foo\\Bar\",\n     *     type: \"REG_DWORD\",\n     *     value: \"Baz\"\n     * }\n     *\n     * // REG_QWORD\n     * {\n     *     data: 13108146671334112,\n     *     rootKey: \"HKEY_LOCAL_MACHINE\",\n     *     subkey: \"Foo\\Bar\",\n     *     type: \"REG_QWORD\",\n     *     value: \"Baz\"\n     * }\n     *\n     * // REG_SZ\n     * {\n     *     data: \"FooBarBaz\",\n     *     rootKey: \"HKEY_LOCAL_MACHINE\",\n     *     subkey: \"Foo\\Bar\",\n     *     type: \"REG_SZ\",\n     *     value: \"Baz\"\n     * }\n     *\n     * // REG_EXPAND_SZ\n     * {\n     *     data: \"C:\\User\\JohnDoe\\AppData\\Local\",\n     *     rootKey: \"HKEY_CURRENT_USER\",\n     *     subkey: \"Foo\\Bar\",\n     *     type: \"REG_EXPAND_SZ\",\n     *     value: \"Baz\"\n     * }\n     *\n     * // REG_MULTI_SZ\n     * {\n     *     data: [\n     *         \"Foo\",\n     *         \"Bar\",\n     *         \"Baz\"\n     *     ],\n     *     rootKey: \"HKEY_CURRENT_USER\",\n     *     subkey: \"Foo\\Bar\",\n     *     type: \"REG_MULTI_SZ\",\n     *     value: \"Baz\"\n     * }\n     *\n     * // REG_BINARY\n     * {\n     *     data: {\n     *         data: [\n     *             255,\n     *             255,\n     *             0,\n     *             43,\n     *             55,\n     *             0,\n     *             0,\n     *             255,\n     *             255\n     *         ],\n     *         type: \"Buffer\"\n     *     },\n     *     rootKey: \"HKEY_CURRENT_USER\",\n     *     subkey: \"Foo\\Bar\",\n     *     type: \"REG_BINARY\",\n     *     value: \"Baz\"\n     * }\n     * ```\n     */\n    readRegistryValue(rootKey, subkey, value) {\n        return this.wire\n            .sendAction('read-registry-value', {\n            rootKey,\n            subkey,\n            value\n        })\n            .then(({ payload }) => payload.data);\n    }\n    /**\n     * This function call will register a unique id and produce a token.\n     * The token can be used to broker an external connection.\n     * @param uuid - A UUID for the remote connection.\n     *\n     * @example\n     * ```js\n     * fin.System.registerExternalConnection(\"remote-connection-uuid\").then(conn => console.log(conn)).catch(err => console.log(err));\n     *\n     *\n     * // object comes back with\n     * //     token: \"0489EAC5-6404-4F0D-993B-92BB8EAB445D\", // this will be unique each time\n     * //     uuid: \"remote-connection-uuid\"\n     *\n     * ```\n     */\n    registerExternalConnection(uuid) {\n        return this.wire.sendAction('register-external-connection', { uuid }).then(({ payload }) => payload.data);\n    }\n    /**\n     * Returns the json blob found in the [desktop owner settings](https://openfin.co/documentation/desktop-owner-settings/)\n     * for the specified service.\n     * @param serviceIdentifier An object containing a name key that identifies the service.\n     *\n     * @remarks More information about desktop services can be found [here](https://developers.openfin.co/docs/desktop-services).\n     * This call will reject if the desktop owner settings file is not present, not correctly formatted, or if the service requested is not configured or configured incorrectly.\n     *\n     * @example\n     * ```js\n     * // Here we are using the [layouts](https://github.com/HadoukenIO/layouts-service) service.\n     * fin.System.getServiceConfiguration({name:'layouts'}).then(console.log).catch(console.error);\n     * ```\n     */\n    async getServiceConfiguration(serviceIdentifier) {\n        if (typeof serviceIdentifier.name !== 'string') {\n            throw new Error('Must provide an object with a `name` property having a string value');\n        }\n        const { name } = serviceIdentifier;\n        return this.wire.sendAction('get-service-configuration', { name }).then(({ payload }) => payload.data);\n    }\n    async getSystemAppConfig(name) {\n        if (typeof name !== 'string') {\n            throw new Error('Must provide a string value for name of system app');\n        }\n        return this.wire.sendAction('get-system-app-configuration', { name }).then(({ payload }) => payload.data);\n    }\n    /**\n     * Registers a system shutdown handler so user can do some cleanup before system is shutting down.\n     * @remarks Once system shutdown starts, you are unable to cancel it.\n     * @param handler system shutdown handler\n     *\n     * @example\n     * ```js\n     * fin.System.registerShutdownHandler((shutdownEvent) => {\n     *         // save state or cleanup\n     *         console.log('do some cleanup before shutdown');\n     *         // Notify app is ready for termination.\n     *         shutdownEvent.proceed();\n     * })\n     * .then(() => console.log('Shutdown handler registered!'))\n     * .catch(err => console.log(err));\n     * ```\n     * @experimental\n     */\n    async registerShutdownHandler(handler) {\n        this.wire.sendAction('system-register-shutdown-handler').catch((e) => {\n            // don't expose, analytics-only call\n        });\n        const SystemShutdownEventName = 'system-shutdown';\n        const SystemShutdownHandledEventName = 'system-shutdown-handled';\n        const { uuid, name } = this.wire.me;\n        const shutdownHandler = (payload) => {\n            const proceed = () => {\n                // notify core that the app is ready for shutdown\n                this.wire.environment.raiseEvent(`application/${SystemShutdownHandledEventName}`, {\n                    uuid,\n                    name,\n                    topic: 'application'\n                });\n            };\n            handler({ proceed });\n        };\n        this.on(SystemShutdownEventName, shutdownHandler);\n    }\n    /**\n     * Signals the RVM to perform a health check and returns the results as json.\n     *\n     * @remarks Requires RVM 5.5+\n     *\n     * @example\n     * ```js\n     * try {\n     *     const results = await fin.System.runRvmHealthCheck();\n     *     console.log(results);\n     * } catch(e) {\n     *      console.error(e);\n     * }\n     * ```\n     */\n    runRvmHealthCheck() {\n        return this.wire.sendAction('run-rvm-health-check').then(({ payload }) => payload.data);\n    }\n    /**\n     * Launch application using a manifest URL/path. It differs from Application.startFromManifest in that this API can accept a manifest using the fin protocol.\n     * @param manifestUrl - The manifest's URL or path.\n     * @param opts - Parameters that the RVM will use.\n     *\n     * @experimental\n     * @remarks Supports protocols http/s and fin/s, and also a local path.\n     *\n     * Note: This API is Windows only.\n     *\n     * @example\n     *\n     * This API can handle most manifest types. Some examples below.\n     *\n     * Traditional:\n     * ```js\n     * const manifest = await fin.System.launchManifest(\n     *   'https://demoappdirectory.openf.in/desktop/config/apps/OpenFin/HelloOpenFin/app.json');\n     * console.log(manifest);\n     * ```\n     *\n     * Platform:\n     * ```js\n     * const manifest = await fin.System.launchManifest('https://openfin.github.io/platform-api-project-seed/public.json');\n     * console.log(manifest);\n     * ```\n     *\n     * Launching traditional manifest into a platform:\n     * ```js\n     * const manifest = await fin.System.launchManifest(\n     *   'https://openfin.github.io/platform-api-project-seed/public.json?\\\n     *   $$appManifestUrl=https://demoappdirectory.openf.in/desktop/config/\\\n     *   apps/OpenFin/HelloOpenFin/app.json');\n     * console.log(manifest);\n     * ```\n     *\n     * Launching with RVM options:\n     * ```js\n     * const manifest = await fin.System.launchManifest('https://openfin.github.io/platform-api-project-seed/public.json',\n     *     { noUi: true, userAppConfigArgs: { abc: '123', xyz: '789' } });\n     * console.log(manifest);\n     * ```\n     *\n     * Local Path:\n     * ```js\n     * const manifest =  await fin.System.launchManifest('file://c:\\\\path\\\\to\\\\manifest\\\\file.json');\n     * console.log(manifest);\n     * ```\n     *\n     * Launching with RVM 'subscribe' option:\n     *\n     * This option allows users to subscribe to app version resolver events when\n     * calling launchManifest with fallbackManifests specified.\n     *\n     * ```js\n     * fin.System.launchManifest('fins://system-apps/notifications/app.json', { subscribe: (launch) => {\n     * \t\tlaunch.on('app-version-progress', (progress) => {\n     * \t\t\tconsole.log(\"Trying manifest \" + progress.manifest)\n     * \t\t});\n     *\n     * \t\tlaunch.on('runtime-status', (status) => {\n     * \t\t\tconsole.log(\"Runtime status: \" + JSON.stringify(status));\n     * \t\t});\n     *\n     * \t\t// RVM has successfully found the target runtime version\n     * \t\tlaunch.on('app-version-complete', (complete) => {\n     * \t\t\tconsole.log(\"Parent app \" + complete.srcManifest + \" resolved to \" + complete.manifest);\n     * \t\t\tlaunch.removeAllListeners();\n     * \t\t});\n     *\n     * \t\t// RVM failed to find an available runtime version\n     * \t\tlaunch.on('app-version-error', (error) => {\n     * \t\t\tconsole.log(\"Failed to resolve \" + error.srcManifest + \" from the fallbackManifests\");\n     * \t\t\tlaunch.removeAllListeners();\n     * \t\t});\n     * \t}\n     * });\n     * ```\n     */\n    async launchManifest(manifestUrl, opts = {}) {\n        const { subscribe, ..._sendOpts } = opts;\n        const sendOpts = _sendOpts;\n        if (subscribe) {\n            const launchEmitter = new events_1$6.EventEmitter();\n            subscribe(launchEmitter);\n            const AppVersionProgressEventName = 'app-version-progress';\n            const RuntimeStatusEventName = 'runtime-status';\n            const AppVersionCompleteEventName = 'app-version-complete';\n            const AppVersionErrorEventName = 'app-version-error';\n            // add id to avoid multiple api calls getting duplicated events\n            const id = this.wire.environment.getNextMessageId().toString();\n            sendOpts.appVersionId = id;\n            const supportedEvents = [\n                AppVersionCompleteEventName,\n                AppVersionProgressEventName,\n                RuntimeStatusEventName,\n                AppVersionErrorEventName\n            ];\n            const cleanEventPayload = (payload) => {\n                // We need to do type castings below to make sure the return type is correct.\n                const { appVersionId, topic, type: typeWithId, ...rest } = payload;\n                const type = supportedEvents.find((x) => typeWithId.includes(x));\n                return {\n                    ...rest,\n                    type\n                };\n            };\n            const appVersionListener = (payload) => {\n                const cleanPayload = cleanEventPayload(payload);\n                launchEmitter.emit(cleanPayload.type, cleanPayload);\n            };\n            const removeAllListeners = () => {\n                this.removeListener(`${AppVersionProgressEventName}.${id}`, appVersionListener);\n                this.removeListener(`${RuntimeStatusEventName}.${id}`, appVersionListener);\n                this.removeListener(`${AppVersionCompleteEventName}.${id}`, appVersionListener);\n                this.removeListener(`${AppVersionErrorEventName}.${id}`, appVersionListener);\n                this.removeListener(`${AppVersionCompleteEventName}.${id}`, removeAllListeners);\n                this.removeListener(`${AppVersionErrorEventName}.${id}`, removeAllListeners);\n            };\n            await Promise.all([\n                this.on(`${AppVersionProgressEventName}.${id}`, appVersionListener),\n                this.on(`${RuntimeStatusEventName}.${id}`, appVersionListener),\n                this.once(`${AppVersionCompleteEventName}.${id}`, appVersionListener),\n                this.once(`${AppVersionErrorEventName}.${id}`, appVersionListener),\n                this.once(`${AppVersionCompleteEventName}.${id}`, removeAllListeners),\n                this.once(`${AppVersionErrorEventName}.${id}`, removeAllListeners)\n            ]);\n        }\n        const response = await this.wire.sendAction('launch-manifest', {\n            manifestUrl,\n            opts: sendOpts\n        });\n        return response.payload.data.manifest;\n    }\n    /**\n     * Query permission of a secured api in current context.\n     *\n     * @param apiName - The full name of a secured API.\n     *\n     * @remarks If a function has a structured permission value, the value of `granted` will reflect the `enabled` key\n     * of the call's permissions literal.  In this case, *permission may still be denied to a call* pending arguments or other\n     * runtime state.  This is indicated with `state: unavailable`.\n     *\n     * @example\n     * ```js\n     * fin.System.queryPermissionForCurrentContext('System.launchExternalProcess').then(result => console.log(result)).catch(err => console.log(err));\n     *\n     * //This response has the following shape:\n     * {\n     *    permission: 'System.launchExternalProcess', // api full name\n     *    state: 'granted', // state of permission\n     *    granted: true\n     * }\n     * ```\n     */\n    async queryPermissionForCurrentContext(apiName) {\n        const identity = { uuid: this.wire.me.uuid, name: this.wire.me.name };\n        const response = await this.wire.sendAction('query-permission-for-current-context', {\n            apiName,\n            identity\n        });\n        return response.payload.data;\n    }\n    // Not documenting, internal use only.\n    async enableNativeWindowIntegrationProvider(permissions) {\n        const { payload } = await this.wire.sendAction('enable-native-window-integration-provider', { permissions });\n        return payload.data;\n    }\n    /**\n     * (Internal) Register the usage of a component with a platform\n     * @param options - Object with data and type\n     *\n     * @example\n     * ```js\n     * async function registerUsage() {\n     *     const app = await fin.System.getCurrent();\n     *     return await fin.System.registerUsage({\n     *         type: 'workspace-licensing',\n     *         // example values for the following data object\n     *         data: {\n     *             apiVersion: '1.0',\n     *             componentName: 'home',\n     *             componentVersion: '1.0',\n     *             allowed: true,\n     *             rejectionCode: ''\n     *         }\n     *     });\n     * }\n     *\n     * registerUsage().then(() => console.log('Successfully registered component application')).catch(err => console.log(err));\n     * ```\n     */\n    async registerUsage({ data, type }) {\n        await this.wire.sendAction('register-usage', { data, type });\n    }\n    /**\n     * Returns an array with all printers of the caller and not all the printers on the desktop.\n     *\n     * @example\n     * ```js\n     * fin.System.getPrinters()\n     *     .then((printers) => {\n     *         printers.forEach((printer) => {\n     *             if (printer.isDefault) {\n     *                 console.log(printer);\n     *             }\n     *         });\n     *     })\n     *     .catch((err) => {\n     *         console.log(err);\n     *     });\n     * ```\n     */\n    async getPrinters() {\n        const { payload } = await this.wire.sendAction('system-get-printers');\n        return payload.data;\n    }\n    /**\n     * Updates Process Logging values: periodic interval and outlier detection entries and interval.\n     * @param options Process Logging updatable options.\n     *\n     * @remarks When enabling verbose mode, additional process information is logged to the debug.log:\n     *\n     * 1. Periodically process usage (memory, cpu, etc) will be logged for each PID along with the windows, views and\n     * iframes that belong to them. The default is every 30 seconds. Updatable by passing the interval option.\n     * 2. When Windows and Views are created or navigated the PID they belong to and their options will be logged.\n     * 3. When Windows and Views are destroyed their last known process usage will be logged.\n     * 4. Whenever an outlier memory usage is detected it will be logged. By default, on an interval of 5 seconds we will\n     * collect process usage for all PIDs and when 144 such entries are collected, we will start analyzing the data for any\n     * possible outliers in the following entries. The interval and maximum number of entries stored in the running buffer\n     * can be updatable by passing the outlierDetection.interval and outlierDetection.entries options.\n     *\n     * @example\n     *\n     * ```js\n     * await fin.System.updateProcessLoggingOptions({\n     *     interval: 10,\n     *     outlierDetection: {\n     *         interval: 15,\n     *         entries: 200\n     *     }\n     * });\n     * ```\n     */\n    async updateProcessLoggingOptions(options) {\n        await this.wire.sendAction('system-update-process-logging-options', { options });\n    }\n    /**\n     * Returns domain settings for the current application.\n     * Initial settings are configured with the defaultDomainSettings application option via manifest.\n     * Domain settings can be overwritten during runtime with System.setDomainSettings.\n     * @example\n     * ```js\n     * const domainSettings = await fin.System.getDomainSettings();\n     * // {\n     * //     \"rules\": [\n     * //         {\n     * //             \"match\": [\n     * //                 \"https://openfin.co\"\n     * //             ],\n     * //             \"options\": {\n     * //                 \"downloadSettings\": {\n     * //                     \"rules\": [\n     * //                         {\n     * //                             \"match\": [\n     * //                                 \"<all_urls>\"\n     * //                             ],\n     * //                             \"behavior\": \"prompt\"\n     * //                         }\n     * //                     ]\n     * //                 }\n     * //             }\n     * //         }\n     * //     ]\n     * // }\n     * ```\n     */\n    async getDomainSettings() {\n        const { payload: { data } } = await this.wire.sendAction('get-domain-settings', this.identity);\n        return data;\n    }\n    /**\n     * Sets the domain settings for the current application.\n     * @param domainSettings - domain settings object\n     * @example\n     * ```js\n     * const domainSettings = await fin.System.getDomainSettings();\n     * // {\n     * //     \"rules\": [\n     * //         {\n     * //             \"match\": [\n     * //                 \"https://openfin.co\"\n     * //             ],\n     * //             \"options\": {\n     * //                 \"downloadSettings\": {\n     * //                     \"rules\": [\n     * //                         {\n     * //                             \"match\": [\n     * //                                 \"<all_urls>\"\n     * //                             ],\n     * //                             \"behavior\": \"prompt\"\n     * //                         }\n     * //                     ]\n     * //                 }\n     * //             }\n     * //         }\n     * //     ]\n     * // }\n     *\n     * // Valid rule behaviors are 'prompt' and 'no-prompt'\n     * domainSettings.rules[0].options.downloadSettings.rules[0].behavior = 'no-prompt';\n     *\n     * await fin.System.setDomainSettings(domainSettings);\n     *\n     * const newDomainSettings = await fin.System.getDomainSettings();\n     * // {\n     * //     \"rules\": [\n     * //         {\n     * //             \"match\": [\n     * //                 \"https://openfin.co\"\n     * //             ],\n     * //             \"options\": {\n     * //                 \"downloadSettings\": {\n     * //                     \"rules\": [\n     * //                         {\n     * //                             \"match\": [\n     * //                                 \"<all_urls>\"\n     * //                             ],\n     * //                             \"behavior\": \"no-prompt\"\n     * //                         }\n     * //                     ]\n     * //                 }\n     * //             }\n     * //         }\n     * //     ]\n     * // }\n     * ```\n     */\n    async setDomainSettings(domainSettings) {\n        await this.wire.sendAction('set-domain-settings', { domainSettings, ...this.identity });\n    }\n    /**\n     * Attempts to install and enable extensions for the security realm.  Users may want to call this function in response\n     * to an `extensions-install-failed` event.  Only extensions allowed by every application on the current security realm\n     * will be installed/enabled.\n     */\n    async refreshExtensions() {\n        const { payload } = await this.wire.sendAction('refresh-extensions');\n        return payload.data;\n    }\n    /**\n     * Gets the currently-installed\n     */\n    async getInstalledExtensions() {\n        const { payload } = await this.wire.sendAction('get-installed-extensions');\n        return payload.data;\n    }\n}\nsystem.System = System;\n\nvar interappbus = {};\n\nvar refCounter = {};\n\nObject.defineProperty(refCounter, \"__esModule\", { value: true });\nrefCounter.RefCounter = void 0;\nclass RefCounter {\n    constructor() {\n        this.topicRefMap = new Map();\n    }\n    // returns the ref count after incrementing\n    incRefCount(key) {\n        const refCount = this.topicRefMap.get(key);\n        let returnCount;\n        if (!refCount) {\n            this.topicRefMap.set(key, 1);\n            returnCount = 1;\n        }\n        else {\n            const newRefCount = refCount + 1;\n            returnCount = newRefCount;\n            this.topicRefMap.set(key, newRefCount);\n        }\n        return returnCount;\n    }\n    // returns the ref count after decrementing, or -1 if the key already had no references\n    decRefCount(key) {\n        const refCount = this.topicRefMap.get(key);\n        let returnCount;\n        if (refCount) {\n            const newRefCount = refCount - 1;\n            this.topicRefMap.set(key, newRefCount);\n            returnCount = newRefCount;\n        }\n        else {\n            returnCount = -1;\n        }\n        return returnCount;\n    }\n    // Execute firstAction if it is the first such ref, else execute nonFirstAction.\n    // In either case the return value is that of the action executed\n    actOnFirst(key, firstAction, nonFirstAction) {\n        const numRefs = this.incRefCount(key);\n        const isFirstRef = numRefs === 1;\n        return isFirstRef ? firstAction() : nonFirstAction();\n    }\n    // Execute lastAction if it is the first such ref, else execute nonLastAction.\n    // In either case the return value is that of the action executed\n    actOnLast(key, lastAction, nonLastAction) {\n        const numRefs = this.decRefCount(key);\n        const isLastRef = numRefs === 0;\n        return isLastRef ? lastAction() : nonLastAction();\n    }\n}\nrefCounter.RefCounter = RefCounter;\n\nvar channel$1 = {};\n\nvar client = {};\n\nvar channel = {};\n\nObject.defineProperty(channel, \"__esModule\", { value: true });\nchannel.ChannelBase = channel.ProtectedItems = void 0;\nconst resultOrPayload = (func) => async (topic, payload, senderIdentity) => {\n    const res = await func(topic, payload, senderIdentity);\n    return res === undefined ? payload : res;\n};\nclass ProtectedItems {\n    /**\n     * @internal\n     */\n    // eslint-disable-next-line no-useless-constructor\n    constructor(providerIdentity, close) {\n        this.providerIdentity = providerIdentity;\n        this.close = close;\n    }\n}\nchannel.ProtectedItems = ProtectedItems;\nclass ChannelBase {\n    static defaultAction(topic) {\n        throw new Error(`No action registered at target for ${topic}`);\n    }\n    constructor() {\n        this.subscriptions = new Map();\n    }\n    async processAction(topic, payload, senderIdentity) {\n        try {\n            const mainAction = this.subscriptions.has(topic)\n                ? this.subscriptions.get(topic)\n                : (currentPayload, id) => (this.defaultAction ?? ChannelBase.defaultAction)(topic, currentPayload, id);\n            const preActionProcessed = this.preAction ? await this.preAction(topic, payload, senderIdentity) : payload;\n            const actionProcessed = await mainAction(preActionProcessed, senderIdentity);\n            return this.postAction ? await this.postAction(topic, actionProcessed, senderIdentity) : actionProcessed;\n        }\n        catch (e) {\n            if (this.errorMiddleware) {\n                return this.errorMiddleware(topic, e, senderIdentity);\n            }\n            throw e;\n        }\n    }\n    /**\n     * Register middleware that fires before the action.\n     *\n     * @param func\n     *\n     * @example\n     *\n     * Channel Provider:\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     provider.register('provider-action', (payload, identity) => {\n     *         console.log(payload, identity);\n     *         return {\n     *             echo: payload\n     *         };\n     *     });\n     *\n     *     provider.beforeAction((action, payload, identity) => {\n     *         //The payload can be altered here before handling the action.\n     *         payload.received = Date.now();\n     *         return payload;\n     *     });\n     *\n     * })();\n     * ```\n     *\n     * Channel Client:\n     * ```js\n     * (async ()=> {\n     *     const client = await fin.InterApplicationBus.Channel.connect('channelName');\n     *\n     *     client.register('client-action', (payload, identity) => {\n     *         console.log(payload, identity);\n     *         return {\n     *             echo: payload\n     *         };\n     *     });\n     *\n     *     client.beforeAction((action, payload, identity) => {\n     *         //The payload can be altered here before handling the action.\n     *         payload.received = Date.now();\n     *         return payload;\n     *     });\n     *\n     *     const providerResponse = await client.dispatch('provider-action', { message: 'Hello From the client' });\n     *     console.log(providerResponse);\n     * })();\n     * ```\n     */\n    beforeAction(func) {\n        if (this.preAction) {\n            throw new Error('Already registered beforeAction middleware');\n        }\n        this.preAction = resultOrPayload(func);\n    }\n    /**\n     * Register an error handler. This is called before responding on any error.\n     *\n     * @param func\n     *\n     * Channel Provider:\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     provider.register('provider-action', (payload, identity) => {\n     *         console.log(payload);\n     *         throw new Error('Action error');\n     *         return {\n     *             echo: payload\n     *         };\n     *     });\n     *\n     *     provider.onError((action, error, identity) => {\n     *         console.log('uncaught Exception in action:', action);\n     *         console.error(error);\n     *     });\n     *\n     * })();\n     * ```\n     *\n     * Channel Client:\n     * ```js\n     * (async ()=> {\n     *     const client = await fin.InterApplicationBus.Channel.connect('channelName');\n     *\n     *     client.register('client-action', (payload, identity) => {\n     *         console.log(payload);\n     *         throw new Error('Action error');\n     *         return {\n     *             echo: payload\n     *         };\n     *     });\n     *\n     *     client.onError((action, error, identity) => {\n     *         console.log('uncaught Exception in action:', action);\n     *         console.error(error);\n     *     });\n     * })();\n     * ```\n     */\n    onError(func) {\n        if (this.errorMiddleware) {\n            throw new Error('Already registered error middleware');\n        }\n        this.errorMiddleware = func;\n    }\n    /**\n     * Register middleware that fires after the action.\n     *\n     * @param func\n     *\n     * @remarks If the action does not return the payload, then the afterAction will not have access to the payload object.\n     *\n     * @example\n     *\n     * Channel Provider:\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     await provider.register('provider-action', (payload, identity) => {\n     *         return {\n     *             echo: payload\n     *         };\n     *     });\n     *\n     *     await provider.afterAction((action, payload, identity) => {\n     *         //the payload can be altered here after handling the action but before sending an acknowledgement.\n     *         payload.sent = date.now();\n     *         return payload;\n     *     });\n     *\n     * })();\n     * ```\n     *\n     * Channel Client:\n     * ```js\n     * (async ()=> {\n     *     const client = await fin.InterApplicationBus.Channel.connect('channelName');\n     *\n     *     await client.register('client-action', (payload, identity) => {\n     *         return {\n     *             echo: payload\n     *         };\n     *     });\n     *\n     *     await client.afterAction((action, payload, identity) => {\n     *         //the payload can be altered here after handling the action but before sending an acknowledgement.\n     *         payload.sent = date.now();\n     *         return payload;\n     *     });\n     *\n     * })();\n     * ```\n     */\n    afterAction(func) {\n        if (this.postAction) {\n            throw new Error('Already registered afterAction middleware');\n        }\n        this.postAction = resultOrPayload(func);\n    }\n    /**\n     * Remove an action by action name.\n     *\n     * @param action\n     *\n     * @example\n     *\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     await provider.register('provider-action', (payload, identity) => {\n     *         console.log(payload);\n     *         return {\n     *             echo: payload\n     *         };\n     *     });\n     *\n     *     await provider.remove('provider-action');\n     *\n     * })();\n     * ```\n     */\n    remove(action) {\n        this.subscriptions.delete(action);\n    }\n    /**\n     * Registers a default action. This is used any time an action that has not been registered is invoked.\n     *\n     * @example\n     *\n     * Channel Provider:\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     await provider.setDefaultAction((action, payload, identity) => {\n     *         console.log(`Client with identity ${JSON.stringify(identity)} has attempted to dispatch unregistered action: ${action}.`);\n     *\n     *         return {\n     *             echo: payload\n     *         };\n     *     });\n     *\n     * })();\n     * ```\n     *\n     * Channel Client:\n     * ```js\n     * (async ()=> {\n     *     const client = await fin.InterApplicationBus.Channel.connect('channelName');\n     *\n     *     await client.setDefaultAction((action, payload, identity) => {\n     *         console.log(`Provider with identity ${JSON.stringify(identity)} has attempted to dispatch unregistered action: ${action}.`);\n     *\n     *         return {\n     *             echo: payload\n     *         };\n     *     });\n     *\n     * })();\n     * ```\n     * @param func\n     */\n    setDefaultAction(func) {\n        if (this.defaultAction) {\n            throw new Error('default action can only be set once');\n        }\n        else {\n            this.defaultAction = func;\n        }\n    }\n    /**\n     * Register an action to be called by dispatching from any channelClient or channelProvider.\n     *\n     * @param topic\n     * @param listener\n     *\n     * @remarks The return value will be sent back as an acknowledgement to the original caller. You can throw an\n     * error to send a negative-acknowledgement and the error will reject the promise returned to the sender by the\n     * dispatch call.  Once a listener is registered for a particular action, it stays in place receiving and responding\n     * to incoming messages until it is removed.  This messaging mechanism works exactly the same when messages are\n     * dispatched from the provider to a client.  However, the provider has an additional publish method that sends messages\n     * to all connected clients.\n     *\n     * Because multiple clients can share the same `name` and `uuid`, in order to distinguish between individual clients,\n     * the `identity` argument in a provider's registered action callback contains an `endpointId` property. When dispatching\n     * from a provider to a client, the `endpointId` property must be provided in order to send an action to a specific client.\n     *\n     * @example\n     *\n     * Channel Provider:\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     await provider.register('provider-action', (payload, identity) => {\n     *        console.log('Action dispatched by client: ', identity);\n     *        console.log('Payload sent in dispatch: ', payload);\n     *\n     *        return { echo: payload };\n     *    });\n     * })();\n     * ```\n     *\n     * Channel Client:\n     * ```js\n     * (async ()=> {\n     *     const client = await fin.InterApplicationBus.Channel.connect('channelName');\n     *\n     *     await client.register('client-action', (payload, identity) => {\n     *        console.log('Action dispatched by client: ', identity);\n     *        console.log('Payload sent in dispatch: ', payload);\n     *\n     *        return { echo: payload };\n     *    });\n     * })();\n     * ```\n     */\n    register(topic, listener) {\n        if (this.subscriptions.has(topic)) {\n            throw new Error(`Subscription already registered for action: ${topic}. Unsubscribe before adding new subscription`);\n        }\n        else {\n            this.subscriptions.set(topic, listener);\n            return true;\n        }\n    }\n}\nchannel.ChannelBase = ChannelBase;\n\nvar __classPrivateFieldGet$c = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar __classPrivateFieldSet$a = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar _ChannelClient_protectedObj, _ChannelClient_strategy, _ChannelClient_close;\nObject.defineProperty(client, \"__esModule\", { value: true });\nclient.ChannelClient = void 0;\nconst channel_1$1 = channel;\nconst channelClientsByEndpointId = new Map();\n/**\n * Instance created to enable use of a channel as a client.  Allows for communication with the\n * {@link ChannelProvider ChannelProvider} by invoking an action on the\n * provider via {@link ChannelClient#dispatch dispatch} and to listen for communication\n * from the provider by registering an action via {@link ChannelClient#register register}.\n *\n * ### Synchronous Methods:\n *  * {@link ChannelClient#onDisconnection onDisconnection(listener)}\n *  * {@link ChannelClient#register register(action, listener)}\n *  * {@link ChannelClient#remove remove(action)}\n *\n * ### Asynchronous Methods:\n *  * {@link ChannelClient#disconnect disconnect()}\n *  * {@link ChannelClient#dispatch dispatch(action, payload)}\n *\n * ### Middleware:\n * Middleware functions receive the following arguments: (action, payload, senderId).\n * The return value of the middleware function will be passed on as the payload from beforeAction, to the action listener, to afterAction\n * unless it is undefined, in which case the original payload is used.  Middleware can be used for side effects.\n *  * {@link ChannelClient#setDefaultAction setDefaultAction(middleware)}\n *  * {@link ChannelClient#onError onError(middleware)}\n *  * {@link ChannelClient#beforeAction beforeAction(middleware)}\n *  * {@link ChannelClient#afterAction afterAction(middleware)}\n */\nclass ChannelClient extends channel_1$1.ChannelBase {\n    /**\n     * @internal\n     */\n    static closeChannelByEndpointId(id) {\n        const channel = channelClientsByEndpointId.get(id);\n        if (channel) {\n            __classPrivateFieldGet$c(channel, _ChannelClient_close, \"f\").call(channel);\n        }\n    }\n    /**\n     * @internal\n     * closes the corresponding channel and invokes the disconnect listener if an event payload is passed.\n     */\n    static handleProviderDisconnect(eventPayload) {\n        for (const channelClient of channelClientsByEndpointId.values()) {\n            if (channelClient.providerIdentity.channelId === eventPayload.channelId) {\n                channelClient.disconnectListener(eventPayload);\n                __classPrivateFieldGet$c(channelClient, _ChannelClient_close, \"f\").call(channelClient);\n            }\n        }\n    }\n    /**\n     * @internal\n     */\n    constructor(routingInfo, close, strategy) {\n        super();\n        _ChannelClient_protectedObj.set(this, void 0);\n        _ChannelClient_strategy.set(this, void 0);\n        // needs to be bound;\n        this.processAction = (action, payload, senderIdentity) => super.processAction(action, payload, senderIdentity);\n        _ChannelClient_close.set(this, () => {\n            channelClientsByEndpointId.delete(this.endpointId);\n            __classPrivateFieldGet$c(this, _ChannelClient_strategy, \"f\").close();\n        });\n        __classPrivateFieldSet$a(this, _ChannelClient_protectedObj, new channel_1$1.ProtectedItems(routingInfo, close), \"f\");\n        this.disconnectListener = () => undefined;\n        this.endpointId = routingInfo.endpointId;\n        __classPrivateFieldSet$a(this, _ChannelClient_strategy, strategy, \"f\");\n        channelClientsByEndpointId.set(this.endpointId, this);\n        strategy.receive(this.processAction);\n    }\n    /**\n     * a read-only provider identity\n     */\n    get providerIdentity() {\n        const protectedObj = __classPrivateFieldGet$c(this, _ChannelClient_protectedObj, \"f\");\n        return protectedObj.providerIdentity;\n    }\n    /**\n     * Dispatch the given action to the channel provider. Returns a promise that resolves with the response from\n     * the provider for that action.\n     *\n     * @param action\n     * @param payload\n     *\n     * @example\n     *\n     * ```js\n     * (async ()=> {\n     *     const client = await fin.InterApplicationBus.Channel.connect('channelName');\n     *\n     *     await client.register('client-action', (payload, identity) => {\n     *         console.log(payload, identity);\n     *         return {\n     *             echo: payload\n     *         };\n     *     });\n     *\n     *     const providerResponse = await client.dispatch('provider-action', { message: 'Hello From the client'});\n     *     console.log(providerResponse);\n     * })();\n     * ```\n     */\n    async dispatch(action, payload) {\n        if (__classPrivateFieldGet$c(this, _ChannelClient_strategy, \"f\").isEndpointConnected(this.providerIdentity.channelId)) {\n            return __classPrivateFieldGet$c(this, _ChannelClient_strategy, \"f\").send(this.providerIdentity.channelId, action, payload);\n        }\n        throw new Error('The client you are trying to dispatch from is disconnected from the target provider.');\n    }\n    /**\n     * Register a listener that is called on provider disconnection. It is passed the disconnection event of the\n     * disconnecting provider.\n     *\n     * @param listener\n     *\n     * @example\n     *\n     * ```js\n     * (async ()=> {\n     *     const client = await fin.InterApplicationBus.Channel.connect('channelName');\n     *\n     *     await client.onDisconnection(evt => {\n     *         console.log('Provider disconnected', `uuid: ${evt.uuid}, name: ${evt.name}`);\n     *     });\n     * })();\n     * ```\n     */\n    onDisconnection(listener) {\n        this.disconnectListener = (payload) => {\n            try {\n                listener(payload);\n            }\n            catch (err) {\n                throw new Error(`Error while calling the onDisconnection callback: ${err.message}`);\n            }\n            finally {\n                this.disconnectListener = () => undefined;\n            }\n        };\n    }\n    /**\n     * Disconnects the client from the channel.\n     *\n     * @example\n     *\n     * ```js\n     * (async ()=> {\n     *     const client = await fin.InterApplicationBus.Channel.connect('channelName');\n     *\n     *     await client.disconnect();\n     * })();\n     * ```\n     */\n    async disconnect() {\n        await this.sendDisconnectAction();\n        __classPrivateFieldGet$c(this, _ChannelClient_close, \"f\").call(this);\n    }\n    async sendDisconnectAction() {\n        const protectedObj = __classPrivateFieldGet$c(this, _ChannelClient_protectedObj, \"f\");\n        await protectedObj.close();\n    }\n    /**\n     * @internal\n     * Writing this as a static to keep code together, but in environments with a wire, this will be DI'd into the protectedObject class as close.\n     */\n    static async wireClose(wire, providerIdentity, endpointId) {\n        const { channelName, uuid, name } = providerIdentity;\n        await wire.sendAction('disconnect-from-channel', {\n            channelName,\n            uuid,\n            name,\n            endpointId\n        });\n    }\n}\nclient.ChannelClient = ChannelClient;\n_ChannelClient_protectedObj = new WeakMap(), _ChannelClient_strategy = new WeakMap(), _ChannelClient_close = new WeakMap();\n\nvar connectionManager = {};\n\nvar exhaustive = {};\n\nObject.defineProperty(exhaustive, \"__esModule\", { value: true });\nexhaustive.exhaustiveCheck = void 0;\nfunction exhaustiveCheck(value, allowed) {\n    throw new Error(`Unsupported value: ${value}${allowed ? `\\n Supported values are: ${allowed.join('')}` : ''}`);\n}\nexhaustive.exhaustiveCheck = exhaustiveCheck;\n\nvar strategy$3 = {};\n\nvar __classPrivateFieldSet$9 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar __classPrivateFieldGet$b = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar _ClassicStrategy_wire, _ClassicStrategy_endpointIdentityMap, _ClassicStrategy_pendingMessagesByEndpointId;\nObject.defineProperty(strategy$3, \"__esModule\", { value: true });\nstrategy$3.ClassicInfo = strategy$3.ClassicStrategy = void 0;\n/*\nThis is used to abstract out ipc messaging from the channels implementation. It is only concerned with sending messages and registration with the MessageReceiver\n*/\nclass ClassicStrategy {\n    constructor(wire, messageReceiver, endpointId, // Provider endpointId is channelId\n    providerIdentity) {\n        this.messageReceiver = messageReceiver;\n        this.endpointId = endpointId;\n        this.providerIdentity = providerIdentity;\n        _ClassicStrategy_wire.set(this, void 0);\n        // Store full endpointIdentity by endpointId of all known endpoints for this strategy instance.\n        // (clients will only have 1: the provider, the provider will have all clients)\n        _ClassicStrategy_endpointIdentityMap.set(this, new Map());\n        // Store a set of cancellable promises to be able to reject them when client\n        // connection problems occur\n        _ClassicStrategy_pendingMessagesByEndpointId.set(this, new Map);\n        this.send = async (endpointId, action, payload) => {\n            const to = __classPrivateFieldGet$b(this, _ClassicStrategy_endpointIdentityMap, \"f\").get(endpointId);\n            if (!to) {\n                throw new Error(`Could not locate routing info for endpoint ${endpointId}`);\n            }\n            // as casting to any because typescript complains. The following is only relevant if this is a locally set endpointId on a ClientIdentity.\n            // We delete these properties to not change backwards compatibility.\n            const cleanId = { ...to };\n            if (cleanId.isLocalEndpointId) {\n                delete cleanId.endpointId;\n            }\n            delete cleanId.isLocalEndpointId;\n            // grab the promise before awaiting it to save in our pending messages map\n            const p = __classPrivateFieldGet$b(this, _ClassicStrategy_wire, \"f\")\n                .sendAction('send-channel-message', {\n                ...cleanId,\n                providerIdentity: this.providerIdentity,\n                action,\n                payload\n            });\n            __classPrivateFieldGet$b(this, _ClassicStrategy_pendingMessagesByEndpointId, \"f\").get(endpointId)?.add(p);\n            const raw = await p.catch((error) => {\n                throw new Error(error.message);\n            }).finally(() => {\n                // clean up the pending promise\n                __classPrivateFieldGet$b(this, _ClassicStrategy_pendingMessagesByEndpointId, \"f\").get(endpointId)?.delete(p);\n            });\n            return raw.payload.data.result;\n        };\n        this.close = async () => {\n            this.messageReceiver.removeEndpoint(this.providerIdentity.channelId, this.endpointId);\n            [...__classPrivateFieldGet$b(this, _ClassicStrategy_endpointIdentityMap, \"f\").keys()].forEach((id) => this.closeEndpoint(id));\n            __classPrivateFieldSet$9(this, _ClassicStrategy_endpointIdentityMap, new Map(), \"f\");\n        };\n        __classPrivateFieldSet$9(this, _ClassicStrategy_wire, wire, \"f\");\n    }\n    onEndpointDisconnect(endpointId, listener) {\n        // Never fires for 'classic'.\n    }\n    receive(listener) {\n        this.messageReceiver.addEndpoint(listener, this.providerIdentity.channelId, this.endpointId);\n    }\n    async closeEndpoint(endpointId) {\n        const id = __classPrivateFieldGet$b(this, _ClassicStrategy_endpointIdentityMap, \"f\").get(endpointId);\n        __classPrivateFieldGet$b(this, _ClassicStrategy_endpointIdentityMap, \"f\").delete(endpointId);\n        const pendingSet = __classPrivateFieldGet$b(this, _ClassicStrategy_pendingMessagesByEndpointId, \"f\").get(endpointId);\n        pendingSet?.forEach((p) => {\n            const errorMsg = `Channel connection with identity uuid: ${id?.uuid} / name: ${id?.name} / endpointId: ${endpointId} no longer connected.`;\n            p.cancel(new Error(errorMsg));\n        });\n    }\n    isEndpointConnected(endpointId) {\n        return __classPrivateFieldGet$b(this, _ClassicStrategy_endpointIdentityMap, \"f\").has(endpointId);\n    }\n    addEndpoint(endpointId, payload) {\n        __classPrivateFieldGet$b(this, _ClassicStrategy_endpointIdentityMap, \"f\").set(endpointId, payload.endpointIdentity);\n        __classPrivateFieldGet$b(this, _ClassicStrategy_pendingMessagesByEndpointId, \"f\").set(endpointId, new Set());\n    }\n    isValidEndpointPayload(payload) {\n        return (typeof payload?.endpointIdentity?.endpointId === 'string' ||\n            typeof payload?.endpointIdentity?.channelId === 'string');\n    }\n}\nstrategy$3.ClassicStrategy = ClassicStrategy;\n_ClassicStrategy_wire = new WeakMap(), _ClassicStrategy_endpointIdentityMap = new WeakMap(), _ClassicStrategy_pendingMessagesByEndpointId = new WeakMap();\n// Arbitrarily starting at 5 to leave the door open to backfilling pre endpointId etc.\nstrategy$3.ClassicInfo = { version: 5, minimumVersion: 0, type: 'classic' };\n\nvar strategy$2 = {};\n\nvar endpoint = {};\n\nvar errors = {};\n\nObject.defineProperty(errors, \"__esModule\", { value: true });\nerrors.errorToPOJO = void 0;\nfunction errorToPOJO(error) {\n    return {\n        stack: error.stack,\n        name: error.name,\n        message: error.message,\n        // support the case where stack is empty or missing\n        toString: () => error.stack || error.toString()\n    };\n}\nerrors.errorToPOJO = errorToPOJO;\n\nvar __classPrivateFieldGet$a = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar __classPrivateFieldSet$8 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar _RTCEndpoint_processAction, _RTCEndpoint_disconnectListener;\nObject.defineProperty(endpoint, \"__esModule\", { value: true });\nendpoint.RTCEndpoint = void 0;\n/* eslint-disable @typescript-eslint/no-unused-vars */\nconst errors_1$1 = errors;\n/*\nThis handles sending RTC messages between RTC connections over the request and response data channels.\n*/\nclass RTCEndpoint {\n    static isValidEndpointPayload(payload) {\n        const isObject = (x) => {\n            return typeof x === 'object' && x !== null;\n        };\n        return (\n        // TODO in factory PR:\n        // payload.type === 'rtc' &&\n        isObject(payload) &&\n            isObject(payload.endpointIdentity) &&\n            isObject(payload.rtc) &&\n            typeof payload.endpointIdentity.endpointId === 'string');\n    }\n    constructor({ rtc, endpointIdentity }) {\n        this.responseMap = new Map();\n        _RTCEndpoint_processAction.set(this, null);\n        _RTCEndpoint_disconnectListener.set(this, void 0);\n        this.connectionStateChangeHandler = (event) => {\n            if (this.rtc.rtcClient.connectionState !== 'connected') {\n                this.rtc.rtcClient.removeEventListener('connectionstatechange', this.connectionStateChangeHandler);\n                this.close();\n                if (__classPrivateFieldGet$a(this, _RTCEndpoint_disconnectListener, \"f\")) {\n                    __classPrivateFieldGet$a(this, _RTCEndpoint_disconnectListener, \"f\").call(this);\n                }\n            }\n        };\n        this.send = async (action, payload) => {\n            const messageId = `message-${Math.random()}`;\n            const promise = new Promise((resolve, reject) => {\n                this.responseMap.set(messageId, { resolve, reject });\n            });\n            this.rtc.channels.request.send(JSON.stringify({ action, payload, messageId }));\n            return promise;\n        };\n        this.close = () => {\n            this.responseMap.forEach((response) => response.reject('Connection has closed.'));\n            this.responseMap = new Map();\n            this.rtc.channels.request.close();\n            this.rtc.channels.response.close();\n            this.rtc.rtcClient.close();\n        };\n        this.rtc = rtc;\n        this.endpointIdentity = endpointIdentity;\n        this.rtc.channels.response.addEventListener('message', (e) => {\n            let { data } = e;\n            if (e.data instanceof ArrayBuffer) {\n                data = new TextDecoder().decode(e.data);\n            }\n            const { messageId, payload, success, error } = JSON.parse(data);\n            const { resolve, reject } = this.responseMap.get(messageId) ?? {};\n            if (resolve && reject) {\n                this.responseMap.delete(messageId);\n                if (success) {\n                    resolve(payload);\n                }\n                else {\n                    reject(error);\n                }\n            }\n            else {\n                console.log('Could not find id in responseMap.');\n                console.log(e);\n            }\n        });\n        this.rtc.channels.request.addEventListener('message', async (e) => {\n            let { data } = e;\n            if (e.data instanceof ArrayBuffer) {\n                data = new TextDecoder().decode(e.data);\n            }\n            const { messageId, action, payload } = JSON.parse(data);\n            if (__classPrivateFieldGet$a(this, _RTCEndpoint_processAction, \"f\")) {\n                try {\n                    const res = await __classPrivateFieldGet$a(this, _RTCEndpoint_processAction, \"f\").call(this, action, payload, endpointIdentity);\n                    this.rtc.channels.response.send(JSON.stringify({\n                        messageId,\n                        payload: res,\n                        success: true\n                    }));\n                }\n                catch (error) {\n                    // Check if RTCDataChannel is open before sending, error gets swallowed here in the case where\n                    // client dispatched then closed or disconnected before the dispatch resolves.\n                    if (this.rtc.channels.response.readyState === 'open') {\n                        this.rtc.channels.response.send(JSON.stringify({\n                            messageId,\n                            error: (0, errors_1$1.errorToPOJO)(error),\n                            success: false\n                        }));\n                    }\n                }\n                // Check if RTCDataChannel is open for same reason as catch block above.\n            }\n            else if (this.rtc.channels.response.readyState === 'open') {\n                this.rtc.channels.response.send(JSON.stringify({\n                    messageId,\n                    success: false,\n                    error: 'Connection not ready.'\n                }));\n            }\n        });\n        this.rtc.rtcClient.addEventListener('connectionstatechange', this.connectionStateChangeHandler);\n        // Disconnect if data channels close unexpectedly, e.g. can happen due to message size > ~255kB (RTCPeerConnection.sctp.maxMessageSizeLimit: 262144)\n        Object.values(this.rtc.channels).forEach((datachannel) => {\n            datachannel.onclose = (e) => {\n                [...this.responseMap.values()].forEach((promise) => promise.reject(new Error('RTCDataChannel closed unexpectedly, this is most commonly caused by message size. Note: RTC Channels have a message size limit of ~255kB.')));\n                this.close();\n                if (__classPrivateFieldGet$a(this, _RTCEndpoint_disconnectListener, \"f\")) {\n                    __classPrivateFieldGet$a(this, _RTCEndpoint_disconnectListener, \"f\").call(this);\n                }\n            };\n        });\n    }\n    onDisconnect(listener) {\n        if (!__classPrivateFieldGet$a(this, _RTCEndpoint_disconnectListener, \"f\")) {\n            __classPrivateFieldSet$8(this, _RTCEndpoint_disconnectListener, listener, \"f\");\n        }\n        else {\n            throw new Error('RTCEndpoint disconnectListener cannot be set twice.');\n        }\n    }\n    receive(listener) {\n        if (__classPrivateFieldGet$a(this, _RTCEndpoint_processAction, \"f\")) {\n            throw new Error('You have already set a listener for this RTC Endpoint.');\n        }\n        __classPrivateFieldSet$8(this, _RTCEndpoint_processAction, listener, \"f\");\n    }\n    get connected() {\n        return this.rtc.rtcClient.connectionState === 'connected';\n    }\n}\nendpoint.RTCEndpoint = RTCEndpoint;\n_RTCEndpoint_processAction = new WeakMap(), _RTCEndpoint_disconnectListener = new WeakMap();\n\nvar strategy$1 = {};\n\nvar __classPrivateFieldGet$9 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar __classPrivateFieldSet$7 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar _EndpointStrategy_processAction, _EndpointStrategy_endpointMap, _EndpointStrategy_connected;\nObject.defineProperty(strategy$1, \"__esModule\", { value: true });\nstrategy$1.EndpointStrategy = void 0;\nclass EndpointStrategy {\n    // Need to pass in validate endpoint separately from constructor because ts interfaces don't do well with static methods\n    constructor(EndpointType, validateEndpoint, StrategyName) {\n        this.EndpointType = EndpointType;\n        this.StrategyName = StrategyName;\n        _EndpointStrategy_processAction.set(this, null);\n        _EndpointStrategy_endpointMap.set(this, new Map());\n        _EndpointStrategy_connected.set(this, true);\n        this.send = async (endpointId, action, payload) => {\n            return this.getEndpointById(endpointId).send(action, payload);\n        };\n        this.close = async () => {\n            if (__classPrivateFieldGet$9(this, _EndpointStrategy_connected, \"f\")) {\n                __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, \"f\").forEach((endpoint) => endpoint.close());\n                __classPrivateFieldSet$7(this, _EndpointStrategy_endpointMap, new Map(), \"f\");\n            }\n            __classPrivateFieldSet$7(this, _EndpointStrategy_connected, false, \"f\");\n        };\n        this.isValidEndpointPayload = validateEndpoint;\n    }\n    onEndpointDisconnect(endpointId, listener) {\n        this.getEndpointById(endpointId).onDisconnect(listener);\n    }\n    receive(listener) {\n        if (__classPrivateFieldGet$9(this, _EndpointStrategy_processAction, \"f\")) {\n            throw new Error(`You have already set a listener for this ${this.StrategyName} Strategy`);\n        }\n        __classPrivateFieldSet$7(this, _EndpointStrategy_processAction, listener, \"f\");\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, \"f\").forEach((endpoint) => endpoint.receive(__classPrivateFieldGet$9(this, _EndpointStrategy_processAction, \"f\")));\n    }\n    getEndpointById(endpointId) {\n        const endpoint = __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, \"f\").get(endpointId);\n        if (!endpoint) {\n            throw new Error(`Client with endpoint id ${endpointId} is not connected`);\n        }\n        return endpoint;\n    }\n    get connected() {\n        return __classPrivateFieldGet$9(this, _EndpointStrategy_connected, \"f\");\n    }\n    isEndpointConnected(endpointId) {\n        return __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, \"f\").has(endpointId);\n    }\n    addEndpoint(endpointId, payload) {\n        if (!__classPrivateFieldGet$9(this, _EndpointStrategy_connected, \"f\")) {\n            console.warn(`Adding endpoint to disconnected ${this.StrategyName} Strategy`);\n            return;\n        }\n        const clientStrat = new this.EndpointType(payload);\n        if (__classPrivateFieldGet$9(this, _EndpointStrategy_processAction, \"f\")) {\n            clientStrat.receive(__classPrivateFieldGet$9(this, _EndpointStrategy_processAction, \"f\"));\n        }\n        __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, \"f\").set(endpointId, clientStrat);\n    }\n    async closeEndpoint(endpointId) {\n        __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, \"f\").delete(endpointId);\n    }\n}\nstrategy$1.EndpointStrategy = EndpointStrategy;\n_EndpointStrategy_processAction = new WeakMap(), _EndpointStrategy_endpointMap = new WeakMap(), _EndpointStrategy_connected = new WeakMap();\n\nObject.defineProperty(strategy$2, \"__esModule\", { value: true });\nstrategy$2.RTCInfo = strategy$2.RTCStrategy = void 0;\n/* eslint-disable @typescript-eslint/no-unused-vars */\n/* eslint-disable class-methods-use-this */\nconst endpoint_1 = endpoint;\nconst strategy_1$1 = strategy$1;\n/*\nThis is used to abstract out rtc messaging from the channels implementation using RTCEndpoints.\n*/\nclass RTCStrategy extends strategy_1$1.EndpointStrategy {\n    constructor() {\n        super(endpoint_1.RTCEndpoint, endpoint_1.RTCEndpoint.isValidEndpointPayload, 'RTC');\n    }\n}\nstrategy$2.RTCStrategy = RTCStrategy;\nstrategy$2.RTCInfo = { version: 2, minimumVersion: 0, type: 'rtc' };\n\nvar iceManager = {};\n\nObject.defineProperty(iceManager, \"__esModule\", { value: true });\niceManager.RTCICEManager = void 0;\nconst base_1$h = base;\n/*\nSingleton that facilitates Offer and Answer exchange required for establishing RTC connections.\n*/\nclass RTCICEManager extends base_1$h.EmitterBase {\n    constructor(wire) {\n        super(wire, 'channel');\n        this.ensureChannelOpened = (channel) => {\n            return new Promise((resolve, reject) => {\n                if (channel.readyState === 'open') {\n                    resolve();\n                }\n                else if (channel.readyState === 'connecting') {\n                    const listener = () => {\n                        channel.removeEventListener('open', listener);\n                        resolve();\n                    };\n                    channel.addEventListener('open', listener);\n                }\n                else {\n                    reject(new Error('This Channel has already closed'));\n                }\n            });\n        };\n    }\n    static createDataChannelPromise(label, rtcClient) {\n        let resolver;\n        const promise = new Promise((resolve) => {\n            resolver = resolve;\n        });\n        const listener = (e) => {\n            const openListener = () => {\n                e.channel.removeEventListener('open', openListener);\n                resolver(e.channel);\n            };\n            if (e.channel.label === label) {\n                e.channel.addEventListener('open', openListener);\n                rtcClient.removeEventListener('datachannel', listener);\n            }\n        };\n        rtcClient.addEventListener('datachannel', listener);\n        return promise;\n    }\n    async listenForProviderIce(rtcConnectionId, listener) {\n        await this.on(this.createProviderEventName(rtcConnectionId), listener, { timestamp: Date.now() });\n    }\n    async raiseProviderIce(rtcConnectionId, payload) {\n        await this.wire.environment.raiseEvent(this.createRouteString(this.createProviderEventName(rtcConnectionId)), payload);\n    }\n    async listenForClientIce(rtcConnectionId, listener) {\n        await this.on(this.createClientEventName(rtcConnectionId), listener, { timestamp: Date.now() });\n    }\n    async raiseClientIce(rtcConnectionId, payload) {\n        await this.wire.environment.raiseEvent(this.createRouteString(this.createClientEventName(rtcConnectionId)), payload);\n    }\n    cleanupIceListeners(rtcConnectionId) {\n        this.removeAllListeners(this.createClientEventName(rtcConnectionId));\n        this.removeAllListeners(this.createProviderEventName(rtcConnectionId));\n    }\n    createClientEventName(rtcConnectionId) {\n        return `ice-client-${rtcConnectionId}`;\n    }\n    createProviderEventName(rtcConnectionId) {\n        return `ice-provider-${rtcConnectionId}`;\n    }\n    createRouteString(name) {\n        return `channel/${name}`;\n    }\n    createRtcPeer() {\n        return this.wire.environment.getRtcPeer();\n    }\n    async startClientOffer() {\n        // TODO replace with real guid.\n        const rtcConnectionId = Math.random().toString();\n        const rtcClient = this.createRtcPeer();\n        rtcClient.addEventListener('icecandidate', async (e) => {\n            if (e.candidate) {\n                await this.raiseClientIce(rtcConnectionId, { candidate: e.candidate?.toJSON() });\n            }\n        });\n        await this.listenForProviderIce(rtcConnectionId, async (payload) => {\n            await rtcClient.addIceCandidate(payload.candidate);\n        });\n        const channels = {\n            request: rtcClient.createDataChannel('request'),\n            response: rtcClient.createDataChannel('response')\n        };\n        const offer = await rtcClient.createOffer();\n        await rtcClient.setLocalDescription(offer);\n        const channelsOpened = Promise.all([channels.request, channels.response].map(this.ensureChannelOpened)).then(() => undefined);\n        return { rtcClient, channels, offer, rtcConnectionId, channelsOpened };\n    }\n    async finishClientOffer(rtcClient, answer, providerReady) {\n        await rtcClient.setRemoteDescription(answer);\n        await providerReady;\n        return true;\n    }\n    async createProviderAnswer(rtcConnectionId, offer) {\n        const rtcClient = this.createRtcPeer();\n        const requestChannelPromise = RTCICEManager.createDataChannelPromise('request', rtcClient);\n        const responseChannelPromise = RTCICEManager.createDataChannelPromise('response', rtcClient);\n        rtcClient.addEventListener('icecandidate', async (e) => {\n            if (e.candidate) {\n                await this.raiseProviderIce(rtcConnectionId, { candidate: e.candidate?.toJSON() });\n            }\n        });\n        await this.listenForClientIce(rtcConnectionId, async (payload) => {\n            await rtcClient.addIceCandidate(payload.candidate);\n        });\n        await rtcClient.setRemoteDescription(offer);\n        const answer = await rtcClient.createAnswer();\n        await rtcClient.setLocalDescription(answer);\n        const channels = Promise.all([requestChannelPromise, responseChannelPromise]).then(([request, response]) => {\n            // Clean up ice events.\n            this.cleanupIceListeners(rtcConnectionId);\n            return { request, response };\n        });\n        return {\n            rtcClient,\n            answer,\n            channels\n        };\n    }\n}\niceManager.RTCICEManager = RTCICEManager;\n\nvar provider = {};\n\nvar runtimeVersioning = {};\n\nObject.defineProperty(runtimeVersioning, \"__esModule\", { value: true });\nruntimeVersioning.runtimeUuidMeetsMinimumRuntimeVersion = runtimeVersioning.parseRuntimeUuid = runtimeVersioning.meetsMinimumRuntimeVersion = void 0;\nfunction vNum(x) {\n    return [...x.split('.').reverse().entries()].reduce((p, [i, v]) => p + +v * 10000 ** i, 0);\n}\n/*\n  Compares runtime versions to see if the current runtime meets your desired minimum.\n*/\nfunction meetsMinimumRuntimeVersion(currentVersion, minVersion) {\n    const currentVersionParsed = vNum(currentVersion);\n    const minVersionParsed = vNum(minVersion);\n    return currentVersionParsed >= minVersionParsed;\n}\nruntimeVersioning.meetsMinimumRuntimeVersion = meetsMinimumRuntimeVersion;\n// Strips the port info from the runtimeUuid, leaving just the runtime version.\nfunction parseRuntimeUuid(runtimeUuid) {\n    return runtimeUuid.split('/')[0];\n}\nruntimeVersioning.parseRuntimeUuid = parseRuntimeUuid;\nfunction runtimeUuidMeetsMinimumRuntimeVersion(runtimeUuid, minVersion) {\n    const runtimeVersion = parseRuntimeUuid(runtimeUuid);\n    return meetsMinimumRuntimeVersion(runtimeVersion, minVersion);\n}\nruntimeVersioning.runtimeUuidMeetsMinimumRuntimeVersion = runtimeUuidMeetsMinimumRuntimeVersion;\n\nvar __classPrivateFieldGet$8 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar __classPrivateFieldSet$6 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar _ChannelProvider_connections, _ChannelProvider_protectedObj, _ChannelProvider_strategy, _ChannelProvider_removeEndpoint, _ChannelProvider_close;\nObject.defineProperty(provider, \"__esModule\", { value: true });\nprovider.ChannelProvider = void 0;\nconst channel_1 = channel;\nconst runtimeVersioning_1 = runtimeVersioning;\n/**\n * Instance created to enable use of a channel as a provider. Allows for communication with the {@link ChannelClient ChannelClients} by invoking an action on\n * a single client via {@link ChannelProvider#dispatch dispatch} or all clients via {@link ChannelProvider#publish publish}\n * and to listen for communication from clients by registering an action via {@link ChannelProvider#register register}.\n *\n * ### Synchronous Methods:\n *  * {@link ChannelProvider#onConnection onConnection(listener)}\n *  * {@link ChannelProvider#onDisconnection onDisconnection(listener)}\n *  * {@link ChannelProvider#publish publish(action, payload)}\n *  * {@link ChannelProvider#register register(action, listener)}\n *  * {@link ChannelProvider#remove remove(action)}\n *\n * ### Asynchronous Methods:\n *  * {@link ChannelProvider#destroy destroy()}\n *  * {@link ChannelProvider#dispatch dispatch(to, action, payload)}\n *  * {@link ChannelProvider#getAllClientInfo getAllClientInfo()}\n *\n * ### Middleware:\n * Middleware functions receive the following arguments: (action, payload, senderId).\n * The return value of the middleware function will be passed on as the payload from beforeAction, to the action listener, to afterAction\n * unless it is undefined, in which case the most recently defined payload is used.  Middleware can be used for side effects.\n *  * {@link ChannelProvider#setDefaultAction setDefaultAction(middleware)}\n *  * {@link ChannelProvider#onError onError(middleware)}\n *  * {@link ChannelProvider#beforeAction beforeAction(middleware)}\n *  * {@link ChannelProvider#afterAction afterAction(middleware)}\n */\nclass ChannelProvider extends channel_1.ChannelBase {\n    /**\n     * a read-only array containing all the identities of connecting clients.\n     */\n    get connections() {\n        return [...__classPrivateFieldGet$8(this, _ChannelProvider_connections, \"f\")];\n    }\n    static handleClientDisconnection(channel, payload) {\n        const removeById = channel.connections.find((identity) => identity.endpointId === payload.endpointId);\n        if (removeById) {\n            __classPrivateFieldGet$8(channel, _ChannelProvider_removeEndpoint, \"f\").call(channel, removeById);\n        }\n        else {\n            const multipleRemoves = channel.connections.filter((identity) => {\n                return identity.uuid === payload.uuid && identity.name === payload.name;\n            });\n            multipleRemoves.forEach(__classPrivateFieldGet$8(channel, _ChannelProvider_removeEndpoint, \"f\"));\n        }\n        channel.disconnectListener(payload);\n    }\n    static setProviderRemoval(provider, remove) {\n        ChannelProvider.removalMap.set(provider, remove);\n    }\n    /**\n     * @internal\n     */\n    constructor(providerIdentity, close, strategy) {\n        super();\n        _ChannelProvider_connections.set(this, void 0);\n        _ChannelProvider_protectedObj.set(this, void 0);\n        _ChannelProvider_strategy.set(this, void 0);\n        _ChannelProvider_removeEndpoint.set(this, (identity) => {\n            const remainingConnections = this.connections.filter((clientIdentity) => clientIdentity.endpointId !== identity.endpointId);\n            __classPrivateFieldGet$8(this, _ChannelProvider_strategy, \"f\").closeEndpoint(identity.endpointId);\n            __classPrivateFieldSet$6(this, _ChannelProvider_connections, remainingConnections, \"f\");\n        });\n        // Must be bound.\n        this.processAction = async (action, payload, senderIdentity) => {\n            if (ChannelProvider.clientIsMultiRuntime(senderIdentity) &&\n                !(0, runtimeVersioning_1.runtimeUuidMeetsMinimumRuntimeVersion)(senderIdentity.runtimeUuid, '18.87.56.0')) {\n                this.handleMultiRuntimeLegacyClient(senderIdentity);\n            }\n            else {\n                this.checkForClientConnection(senderIdentity);\n            }\n            return super.processAction(action, payload, senderIdentity);\n        };\n        _ChannelProvider_close.set(this, () => {\n            __classPrivateFieldGet$8(this, _ChannelProvider_strategy, \"f\").close();\n            const remove = ChannelProvider.removalMap.get(this);\n            if (remove) {\n                remove();\n            }\n        });\n        __classPrivateFieldSet$6(this, _ChannelProvider_protectedObj, new channel_1.ProtectedItems(providerIdentity, close), \"f\");\n        this.connectListener = () => undefined;\n        this.disconnectListener = () => undefined;\n        __classPrivateFieldSet$6(this, _ChannelProvider_connections, [], \"f\");\n        __classPrivateFieldSet$6(this, _ChannelProvider_strategy, strategy, \"f\");\n        strategy.receive(this.processAction);\n    }\n    /**\n     * Dispatch an action to a specified client. Returns a promise for the result of executing that action on the client side.\n     *\n     * @param to - Identity of the target client.\n     * @param action - Name of the action to be invoked by the client.\n     * @param payload - Payload to be sent along with the action.\n     *\n     * @remarks\n     *\n     * Because multiple clients can share the same `name` and `uuid`, when dispatching from a provider to a client,\n     * the `identity` you provide must include the client's unique `endpointId` property. This `endpointId` is\n     * passed to the provider in both the `Provider.onConnection` callback and in any registered action callbacks.\n     *\n     * @example\n     *\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     await provider.register('provider-action', async (payload, identity) => {\n     *         console.log(payload, identity);\n     *         return await provider.dispatch(identity, 'client-action', 'Hello, World!');\n     *     });\n     * })();\n     * ```\n     */\n    dispatch(to, action, payload) {\n        const endpointId = to.endpointId ?? this.getEndpointIdForOpenFinId(to, action);\n        if (endpointId && __classPrivateFieldGet$8(this, _ChannelProvider_strategy, \"f\").isEndpointConnected(endpointId)) {\n            return __classPrivateFieldGet$8(this, _ChannelProvider_strategy, \"f\").send(endpointId, action, payload);\n        }\n        return Promise.reject(new Error(`Client connection with identity uuid: ${to.uuid} / name: ${to.name} / endpointId: ${endpointId} no longer connected.`));\n    }\n    async processConnection(senderId, payload) {\n        __classPrivateFieldGet$8(this, _ChannelProvider_connections, \"f\").push(senderId);\n        return this.connectListener(senderId, payload);\n    }\n    /**\n     * Publish an action and payload to every connected client.\n     * Synchronously returns an array of promises for each action (see dispatch).\n     *\n     * @param action\n     * @param payload\n     *\n     * @example\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     await provider.register('provider-action', async (payload, identity) => {\n     *         console.log(payload, identity);\n     *         return await Promise.all(provider.publish('client-action', { message: 'Broadcast from provider'}));\n     *     });\n     * })();\n     * ```\n     */\n    publish(action, payload) {\n        return this.connections.map((to) => __classPrivateFieldGet$8(this, _ChannelProvider_strategy, \"f\").send(to.endpointId, action, payload));\n    }\n    /**\n     * Register a listener that is called on every new client connection.\n     *\n     * @remarks It is passed the identity of the connecting client and a payload if it was provided to Channel.connect.\n     * If you wish to reject the connection, throw an error. Be sure to synchronously provide an onConnection upon receipt of\n     * the channelProvider to ensure all potential client connections are caught by the listener.\n     *\n     * Because multiple clients can exist at the same `name` and `uuid`, in order to distinguish between individual clients,\n     * the `identity` argument in a provider's `onConnection` callback contains an `endpointId` property. When dispatching from a\n     * provider to a client, the `endpointId` property must be provided in order to send an action to a specific client.\n     *\n     * @example\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     provider.onConnection(identity => {\n     *         console.log('Client connected', identity);\n     *     });\n     * })();\n     * ```\n     *\n     * Reject connection:\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     provider.onConnection(identity => {\n     *         throw new Error('Connection Rejected');\n     *     });\n     * })();\n     * ```\n     * @param listener\n     */\n    onConnection(listener) {\n        this.connectListener = listener;\n    }\n    /**\n     * Register a listener that is called on client disconnection. It is passed the disconnection event of the disconnecting\n     * client.\n     *\n     * @param listener\n     *\n     * @example\n     *\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     await provider.onDisconnection(evt => {\n     *         console.log('Client disconnected', `uuid: ${evt.uuid}, name: ${evt.name}`);\n     *     });\n     * })();\n     * ```\n     */\n    onDisconnection(listener) {\n        this.disconnectListener = listener;\n    }\n    /**\n     * Destroy the channel, raises `disconnected` events on all connected channel clients.\n     *\n     * @example\n     *\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     await provider.destroy();\n     * })();\n     * ```\n     */\n    async destroy() {\n        const protectedObj = __classPrivateFieldGet$8(this, _ChannelProvider_protectedObj, \"f\");\n        protectedObj.providerIdentity;\n        __classPrivateFieldSet$6(this, _ChannelProvider_connections, [], \"f\");\n        await protectedObj.close();\n        __classPrivateFieldGet$8(this, _ChannelProvider_close, \"f\").call(this);\n    }\n    /**\n     * Returns an array with info on every Client connected to the Provider\n     *\n     * @example\n     *\n     * ```js\n     * const provider = await fin.InterApplicationBus.Channel.create('openfin');\n     * const client = await fin.InterApplicationBus.Channel.connect('openfin');\n     * const clientInfo = await provider.getAllClientInfo();\n     *\n     * console.log(clientInfo);\n     *\n     * // [\n     * //    {\n     * //        \"uuid\": \"openfin\",\n     * //        \"name\": \"openfin-view\",\n     * //        \"endpointId\": \"6d4c7ca8-4a74-4634-87f8-760558229613\",\n     * //        \"entityType\": \"view\",\n     * //        \"url\": \"https://openfin.co\"\n     * //    },\n     * //    {\n     * //        \"uuid\": \"openfin2\",\n     * //        \"name\": \"openfin-view2\",\n     * //        \"endpointId\": \"4z5d8ab9-2b81-3691-91ex-142179382511\",\n     * //        \"entityType\": \"view\",\n     * //        \"url\": \"https://example.com\"\n     * //    }\n     * //]\n     * ```\n     */\n    async getAllClientInfo() {\n        return this.connections.map((clientInfo) => {\n            const { uuid, name, endpointId, entityType, connectionUrl } = clientInfo;\n            return { uuid, name, endpointId, entityType, connectionUrl };\n        });\n    }\n    checkForClientConnection(clientIdentity) {\n        if (!this.isClientConnected(clientIdentity)) {\n            throw new Error(`This action was sent from a client that is not connected to the provider.\n                    Client Identity: {uuid: ${clientIdentity.uuid}, name: ${clientIdentity.name}, endpointId: ${clientIdentity.endpointId}}`);\n        }\n    }\n    isClientConnected(clientIdentity) {\n        if (ChannelProvider.clientIdentityIncludesEndpointId(clientIdentity)) {\n            return this.connections.some((identity) => {\n                return (\n                // Might be redundant to check for uuid and name here after we get an endpointId match, but just in case\n                identity.endpointId === clientIdentity.endpointId &&\n                    identity.uuid === clientIdentity.uuid &&\n                    identity.name === clientIdentity.name);\n            });\n        }\n        return this.isLegacyClientConnected(clientIdentity);\n    }\n    isLegacyClientConnected(clientIdentity) {\n        return this.connections.some((identity) => {\n            return identity.uuid === clientIdentity.uuid && identity.name === clientIdentity.name;\n        });\n    }\n    handleMultiRuntimeLegacyClient(senderIdentity) {\n        if (!this.isLegacyClientConnected(senderIdentity)) {\n            throw new Error(`This action was sent from a client that is not connected to the provider. Client Identity:\n                    {uuid: ${senderIdentity.uuid}, name: ${senderIdentity.name}, endpointId: ${senderIdentity.endpointId}}`);\n        }\n    }\n    getEndpointIdForOpenFinId(clientIdentity, action) {\n        const matchingConnections = this.connections.filter((c) => c.name === clientIdentity.name && c.uuid === clientIdentity.uuid);\n        if (matchingConnections.length >= 2) {\n            const protectedObj = __classPrivateFieldGet$8(this, _ChannelProvider_protectedObj, \"f\");\n            const { uuid, name } = clientIdentity;\n            const providerUuid = protectedObj?.providerIdentity.uuid;\n            const providerName = protectedObj?.providerIdentity.name;\n            // eslint-disable-next-line no-console\n            console.warn(`WARNING: Dispatch call may have unintended results. The \"to\" argument of your dispatch call is missing the\n                \"endpointId\" parameter. The identity you are dispatching to ({uuid: ${uuid}, name: ${name}})\n                has multiple channelClients for this channel. Your dispatched action: (${action}) from the provider:\n                ({uuid: ${providerUuid}, name: ${providerName}}) will only be processed by the most recently-created client.`);\n        }\n        // Pop to return the most recently created endpointId.\n        return matchingConnections.pop()?.endpointId;\n    }\n    // eslint-disable-next-line class-methods-use-this\n    static clientIdentityIncludesEndpointId(subscriptionIdentity) {\n        return subscriptionIdentity.endpointId !== undefined;\n    }\n    // eslint-disable-next-line class-methods-use-this\n    static clientIsMultiRuntime(subscriptionIdentity) {\n        return subscriptionIdentity.runtimeUuid !== undefined;\n    }\n    static async wireClose(wire, channelName) {\n        await wire.sendAction('destroy-channel', { channelName });\n    }\n}\nprovider.ChannelProvider = ChannelProvider;\n_ChannelProvider_connections = new WeakMap(), _ChannelProvider_protectedObj = new WeakMap(), _ChannelProvider_strategy = new WeakMap(), _ChannelProvider_removeEndpoint = new WeakMap(), _ChannelProvider_close = new WeakMap();\n// The following line should be changed following a typescript update.\n// static #removalMap = new WeakMap<ChannelProvider, Function>();\nChannelProvider.removalMap = new WeakMap();\n\nvar messageReceiver = {};\n\nObject.defineProperty(messageReceiver, \"__esModule\", { value: true });\nmessageReceiver.MessageReceiver = void 0;\nconst client_1$1 = client;\nconst base_1$g = base;\n/*\nThis is a singleton (per fin object) tasked with routing messages coming off the ipc to the correct endpoint.\nIt needs to be a singleton because there can only be one per wire. It tracks both clients and providers' processAction passed in via the strategy.\nIf functionality is not about receiving messages, it does not belong here.\n*/\nclass MessageReceiver extends base_1$g.Base {\n    constructor(wire) {\n        super(wire);\n        this.onmessage = (msg) => {\n            if (msg.action === 'process-channel-message') {\n                this.processChannelMessage(msg);\n                return true;\n            }\n            return false;\n        };\n        this.endpointMap = new Map();\n        this.latestEndpointIdByChannelId = new Map();\n        wire.registerMessageHandler(this.onmessage.bind(this));\n    }\n    async processChannelMessage(msg) {\n        const { senderIdentity, providerIdentity, action, ackToSender, payload, intendedTargetIdentity } = msg.payload;\n        const key = intendedTargetIdentity.channelId ?? // The recipient is a provider\n            intendedTargetIdentity.endpointId ?? // The recipient is a client\n            this.latestEndpointIdByChannelId.get(providerIdentity.channelId); // No endpointId was passed, make best attempt\n        const handler = this.endpointMap.get(key);\n        if (!handler) {\n            ackToSender.payload.success = false;\n            ackToSender.payload.reason = `Client connection with identity uuid: ${this.wire.me.uuid} / name: ${this.wire.me.name} / endpointId: ${key} no longer connected.`;\n            return this.wire.sendRaw(ackToSender);\n        }\n        try {\n            const res = await handler(action, payload, senderIdentity);\n            ackToSender.payload.payload = ackToSender.payload.payload || {};\n            ackToSender.payload.payload.result = res;\n            return this.wire.sendRaw(ackToSender);\n        }\n        catch (e) {\n            ackToSender.payload.success = false;\n            ackToSender.payload.reason = e.message;\n            return this.wire.sendRaw(ackToSender);\n        }\n    }\n    addEndpoint(handler, channelId, endpointId) {\n        this.endpointMap.set(endpointId, handler);\n        // Providers have the same endpointId and channelId.\n        // This is only used when clients are receiving messages from providers, so we shouldn't save provider endpointId here.\n        if (channelId !== endpointId) {\n            this.latestEndpointIdByChannelId.set(channelId, endpointId);\n        }\n    }\n    removeEndpoint(channelId, endpointId) {\n        this.endpointMap.delete(endpointId);\n        if (this.latestEndpointIdByChannelId.get(channelId) === endpointId) {\n            this.latestEndpointIdByChannelId.delete(channelId);\n        }\n    }\n    checkForPreviousClientConnection(channelId) {\n        const endpointIdFromPreviousConnection = this.latestEndpointIdByChannelId.get(channelId);\n        if (endpointIdFromPreviousConnection) {\n            // Not convinced by this way of doing things, but pushing up for now.\n            client_1$1.ChannelClient.closeChannelByEndpointId(endpointIdFromPreviousConnection);\n            // eslint-disable-next-line no-console\n            console.warn('You have created a second connection to an older provider. First connection has been removed from the clientMap');\n            // eslint-disable-next-line no-console\n            console.warn('If the provider calls publish(), you may receive multiple messages.');\n        }\n    }\n}\nmessageReceiver.MessageReceiver = MessageReceiver;\n\nvar protocolManager = {};\n\nObject.defineProperty(protocolManager, \"__esModule\", { value: true });\nprotocolManager.ProtocolManager = void 0;\n/*\nThis should be agnostic of any actual openfin code to be unit testable.\nDependencies on the actual srategies should be handled in ConnectionManager\n*/\nclass ProtocolManager {\n    // eslint-disable-next-line no-useless-constructor\n    constructor(ProtocolsInPreferenceOrder) {\n        this.ProtocolsInPreferenceOrder = ProtocolsInPreferenceOrder;\n        this.DefaultClientProtocols = ['classic'];\n        this.DefaultProviderProtocols = ['classic'];\n        this.getClientProtocols = (protocols) => {\n            const supported = protocols\n                ? this.ProtocolsInPreferenceOrder.filter((x) => protocols.includes(x))\n                : this.DefaultClientProtocols;\n            if (!supported.length) {\n                throw new Error(`No valid protocols were passed in. Accepted values are: ${this.ProtocolsInPreferenceOrder.join(', ')}.`);\n            }\n            return supported;\n        };\n        this.getProviderProtocols = (protocols) => {\n            const supported = protocols\n                ? this.ProtocolsInPreferenceOrder.filter((x) => protocols.includes(x))\n                : this.DefaultProviderProtocols;\n            if (!supported.length) {\n                throw new Error(`No valid protocols were passed in. Accepted values are: ${this.ProtocolsInPreferenceOrder.join(', ')}.`);\n            }\n            return supported;\n        };\n        this.getCompatibleProtocols = (providerProtocols, clientOffer) => {\n            const supported = clientOffer.supportedProtocols.filter((clientProtocol) => providerProtocols.some((providerProtocol) => providerProtocol.type === clientProtocol.type &&\n                clientProtocol.version >= providerProtocol.minimumVersion &&\n                providerProtocol.version >= (clientProtocol.minimumVersion ?? 0)));\n            return supported.slice(0, clientOffer.maxProtocols);\n        };\n    }\n}\nprotocolManager.ProtocolManager = ProtocolManager;\n\nvar strategy = {};\n\nObject.defineProperty(strategy, \"__esModule\", { value: true });\nclass CombinedStrategy {\n    // Making this a static method because the constructor can't be typed.\n    // Otherwise it will error when calling addEndpoint but I'd rather the whole instance be typed as never.\n    static combine(a, b) {\n        return new CombinedStrategy(a, b);\n    }\n    // eslint-disable-next-line no-useless-constructor\n    constructor(primary, secondary) {\n        this.primary = primary;\n        this.secondary = secondary;\n    }\n    onEndpointDisconnect(endpointId, listener) {\n        this.primary.onEndpointDisconnect(endpointId, () => {\n            if (!this.secondary.isEndpointConnected(endpointId)) {\n                listener();\n            }\n        });\n        this.secondary.onEndpointDisconnect(endpointId, () => {\n            if (!this.primary.isEndpointConnected(endpointId)) {\n                listener();\n            }\n        });\n    }\n    isValidEndpointPayload(payload) {\n        return this.primary.isValidEndpointPayload(payload) || this.secondary.isValidEndpointPayload(payload);\n    }\n    async closeEndpoint(endpointId) {\n        await this.primary.closeEndpoint(endpointId);\n        await this.secondary.closeEndpoint(endpointId);\n    }\n    isEndpointConnected(endpoint) {\n        return this.primary.isEndpointConnected(endpoint) || this.secondary.isEndpointConnected(endpoint);\n    }\n    async addEndpoint(endpoint, payload) {\n        if (this.primary.isValidEndpointPayload(payload)) {\n            await this.primary.addEndpoint(endpoint, payload);\n        }\n        if (this.secondary.isValidEndpointPayload(payload)) {\n            await this.secondary.addEndpoint(endpoint, payload);\n        }\n    }\n    receive(listener) {\n        this.primary.receive(listener);\n        this.secondary.receive(listener);\n    }\n    send(endpointId, action, payload) {\n        if (this.primary.isEndpointConnected(endpointId)) {\n            return this.primary.send(endpointId, action, payload);\n        }\n        return this.secondary.send(endpointId, action, payload);\n    }\n    async close() {\n        await Promise.all([this.primary.close(), this.secondary.close()]);\n    }\n}\nstrategy.default = CombinedStrategy;\n\nvar __classPrivateFieldSet$5 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar __classPrivateFieldGet$7 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar __importDefault$1 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nvar _ConnectionManager_messageReceiver, _ConnectionManager_rtcConnectionManager;\nObject.defineProperty(connectionManager, \"__esModule\", { value: true });\nconnectionManager.ConnectionManager = void 0;\nconst exhaustive_1 = exhaustive;\nconst base_1$f = base;\nconst strategy_1 = strategy$3;\nconst strategy_2 = strategy$2;\nconst ice_manager_1 = iceManager;\nconst provider_1$1 = provider;\nconst message_receiver_1 = messageReceiver;\nconst protocol_manager_1 = protocolManager;\nconst strategy_3 = __importDefault$1(strategy);\nclass ConnectionManager extends base_1$f.Base {\n    static getProtocolOptionsFromStrings(protocols) {\n        return protocols.map((protocol) => {\n            switch (protocol) {\n                case 'rtc':\n                    return strategy_2.RTCInfo;\n                case 'classic':\n                    return strategy_1.ClassicInfo;\n                default:\n                    return (0, exhaustive_1.exhaustiveCheck)(protocol, ['rtc', 'classic']);\n            }\n        });\n    }\n    constructor(wire) {\n        super(wire);\n        _ConnectionManager_messageReceiver.set(this, void 0);\n        _ConnectionManager_rtcConnectionManager.set(this, void 0);\n        this.removeChannelFromProviderMap = (channelId) => {\n            this.providerMap.delete(channelId);\n        };\n        this.onmessage = (msg) => {\n            if (msg.action === 'process-channel-connection') {\n                this.processChannelConnection(msg);\n                return true;\n            }\n            return false;\n        };\n        this.providerMap = new Map();\n        this.protocolManager = new protocol_manager_1.ProtocolManager(this.wire.environment.type === 'node' ? ['classic'] : ['rtc', 'classic']);\n        __classPrivateFieldSet$5(this, _ConnectionManager_messageReceiver, new message_receiver_1.MessageReceiver(wire), \"f\");\n        __classPrivateFieldSet$5(this, _ConnectionManager_rtcConnectionManager, new ice_manager_1.RTCICEManager(wire), \"f\");\n        wire.registerMessageHandler(this.onmessage.bind(this));\n    }\n    createProvider(options, providerIdentity) {\n        const opts = Object.assign(this.wire.environment.getDefaultChannelOptions().create, options || {});\n        const protocols = this.protocolManager.getProviderProtocols(opts?.protocols);\n        const createSingleStrategy = (stratType) => {\n            switch (stratType) {\n                case 'rtc':\n                    return new strategy_2.RTCStrategy();\n                case 'classic':\n                    return new strategy_1.ClassicStrategy(this.wire, __classPrivateFieldGet$7(this, _ConnectionManager_messageReceiver, \"f\"), \n                    // Providers do not have an endpointId, use channelId as endpointId in the strategy.\n                    providerIdentity.channelId, providerIdentity);\n                default:\n                    return (0, exhaustive_1.exhaustiveCheck)(stratType, ['rtc', 'classic']);\n            }\n        };\n        const strategies = protocols.map(createSingleStrategy);\n        let strategy;\n        if (strategies.length === 2) {\n            const [a, b] = strategies;\n            strategy = strategy_3.default.combine(a, b);\n        }\n        else if (strategies.length === 1) {\n            [strategy] = strategies;\n        }\n        else {\n            // Should be impossible.\n            throw new Error('failed to combine strategies');\n        }\n        const channel = new provider_1$1.ChannelProvider(providerIdentity, () => provider_1$1.ChannelProvider.wireClose(this.wire, providerIdentity.channelName), strategy);\n        const key = providerIdentity.channelId;\n        this.providerMap.set(key, {\n            provider: channel,\n            strategy,\n            supportedProtocols: ConnectionManager.getProtocolOptionsFromStrings(protocols)\n        });\n        provider_1$1.ChannelProvider.setProviderRemoval(channel, this.removeChannelFromProviderMap.bind(this));\n        return channel;\n    }\n    async createClientOffer(options) {\n        const protocols = this.protocolManager.getClientProtocols(options?.protocols);\n        let rtcPacket;\n        const supportedProtocols = await Promise.all(protocols.map(async (type) => {\n            switch (type) {\n                case 'rtc': {\n                    const { rtcClient, channels, offer, rtcConnectionId, channelsOpened } = await __classPrivateFieldGet$7(this, _ConnectionManager_rtcConnectionManager, \"f\").startClientOffer();\n                    rtcPacket = { rtcClient, channels, channelsOpened };\n                    return {\n                        type: 'rtc',\n                        version: strategy_2.RTCInfo.version,\n                        payload: { offer, rtcConnectionId }\n                    };\n                }\n                case 'classic':\n                    return { type: 'classic', version: strategy_1.ClassicInfo.version };\n                default:\n                    return (0, exhaustive_1.exhaustiveCheck)(type, ['rtc', 'classic']);\n            }\n        }));\n        return {\n            offer: {\n                supportedProtocols,\n                maxProtocols: 2\n            },\n            rtc: rtcPacket\n        };\n    }\n    async createClientStrategy(rtcPacket, routingInfo) {\n        if (!routingInfo.endpointId) {\n            routingInfo.endpointId = this.wire.environment.getNextMessageId();\n            // For New Clients connecting to Old Providers. To prevent multi-dispatching and publishing, we delete previously-connected\n            // clients that are in the same context as the newly-connected client.\n            __classPrivateFieldGet$7(this, _ConnectionManager_messageReceiver, \"f\").checkForPreviousClientConnection(routingInfo.channelId);\n        }\n        const answer = routingInfo.answer ?? {\n            supportedProtocols: [{ type: 'classic', version: 1 }]\n        };\n        const createStrategyFromAnswer = async (protocol) => {\n            if (protocol.type === 'rtc' && rtcPacket) {\n                await __classPrivateFieldGet$7(this, _ConnectionManager_rtcConnectionManager, \"f\").finishClientOffer(rtcPacket.rtcClient, protocol.payload.answer, rtcPacket.channelsOpened);\n                return new strategy_2.RTCStrategy();\n            }\n            if (protocol.type === 'classic') {\n                return new strategy_1.ClassicStrategy(this.wire, __classPrivateFieldGet$7(this, _ConnectionManager_messageReceiver, \"f\"), routingInfo.endpointId, routingInfo);\n            }\n            return null;\n        };\n        const allProtocols = (await Promise.all(answer.supportedProtocols.map(createStrategyFromAnswer))).filter((x) => x !== null);\n        // Clean up logic if provider didn't support rtc.\n        if (rtcPacket && !allProtocols.some((x) => x instanceof strategy_2.RTCStrategy)) {\n            if (rtcPacket) {\n                rtcPacket.rtcClient.close();\n            }\n        }\n        let strategy;\n        if (allProtocols.length >= 2) {\n            strategy = strategy_3.default.combine(allProtocols[0], allProtocols[1]);\n        }\n        else if (allProtocols.length) {\n            [strategy] = allProtocols;\n        }\n        else {\n            // Should be impossible.\n            throw new Error('No compatible protocols');\n        }\n        // as casting rtcPacket because we won't have an rtcStrategy if rtcPacket is undefined;\n        const endpointPayload = { endpointIdentity: routingInfo, rtc: rtcPacket };\n        strategy.addEndpoint(routingInfo.channelId, endpointPayload);\n        return strategy;\n    }\n    async processChannelConnection(msg) {\n        const { clientIdentity, providerIdentity, ackToSender, payload, offer: clientOffer } = msg.payload;\n        if (!clientIdentity.endpointId) {\n            // Should be polyfilled by core but not in cases of node connecting to an old runtime.\n            clientIdentity.endpointId = this.wire.environment.getNextMessageId();\n            clientIdentity.isLocalEndpointId = true;\n        }\n        else {\n            clientIdentity.isLocalEndpointId = false;\n        }\n        const key = providerIdentity.channelId;\n        const bus = this.providerMap.get(key);\n        if (!bus) {\n            ackToSender.payload.success = false;\n            ackToSender.payload.reason = `Channel \"${providerIdentity.channelName}\" has been destroyed.`;\n            return this.wire.sendRaw(ackToSender);\n        }\n        const { provider, strategy, supportedProtocols } = bus;\n        try {\n            if (!(provider instanceof provider_1$1.ChannelProvider)) {\n                throw Error('Cannot connect to a channel client');\n            }\n            const offer = clientOffer ?? {\n                supportedProtocols: [{ type: 'classic', version: 1 }],\n                maxProtocols: 1\n            };\n            const overlappingProtocols = this.protocolManager.getCompatibleProtocols(supportedProtocols, offer);\n            if (!overlappingProtocols.length) {\n                throw new Error('This provider does not support any of the offered protocols.');\n            }\n            const res = await provider.processConnection(clientIdentity, payload);\n            ackToSender.payload.payload = ackToSender.payload.payload || {};\n            // Loop through all supported protocols and accumulate them into the answer\n            // addEndpoint is tricky but we need to wait for channel resolution before adding the endpoint.\n            let clientAnswer = {\n                supportedProtocols: [],\n                endpointPayloadPromise: Promise.resolve({ endpointIdentity: clientIdentity })\n            };\n            clientAnswer = await overlappingProtocols.reduce(async (accumP, protocolToUse) => {\n                const answer = await accumP;\n                if (protocolToUse.type === 'rtc') {\n                    const { answer: rtcAnswer, rtcClient, channels } = await __classPrivateFieldGet$7(this, _ConnectionManager_rtcConnectionManager, \"f\").createProviderAnswer(protocolToUse.payload.rtcConnectionId, protocolToUse.payload.offer);\n                    answer.supportedProtocols.push({\n                        type: 'rtc',\n                        version: strategy_2.RTCInfo.version,\n                        payload: {\n                            answer: rtcAnswer\n                        }\n                    });\n                    answer.endpointPayloadPromise = answer.endpointPayloadPromise.then((endpointPayload) => channels.then((resolvedChannels) => {\n                        return {\n                            ...endpointPayload,\n                            rtc: {\n                                rtcClient,\n                                channels: resolvedChannels\n                            }\n                        };\n                    }));\n                }\n                else {\n                    answer.supportedProtocols.push({ type: 'classic', version: strategy_1.ClassicInfo.version });\n                }\n                return answer;\n            }, Promise.resolve(clientAnswer));\n            // Need to as cast here.\n            clientAnswer.endpointPayloadPromise.then((endpointPayload) => strategy.addEndpoint(clientIdentity.endpointId, endpointPayload));\n            ackToSender.payload.payload.result = res;\n            ackToSender.payload.payload.answer = clientAnswer;\n            return this.wire.sendRaw(ackToSender);\n        }\n        catch (e) {\n            ackToSender.payload.success = false;\n            ackToSender.payload.reason = e.message;\n            return this.wire.sendRaw(ackToSender);\n        }\n    }\n}\nconnectionManager.ConnectionManager = ConnectionManager;\n_ConnectionManager_messageReceiver = new WeakMap(), _ConnectionManager_rtcConnectionManager = new WeakMap();\n\n/**\n * Entry points for the `Channel` subset of the `InterApplicationBus` API (`fin.InterApplicationBus.Channel`).\n *\n * * {@link Channel} contains static members of the `Channel` API, accessible through `fin.InterApplicationBus.Channel`.\n * * {@link OpenFin.ChannelClient} describes a client of a channel, e.g. as returned by `fin.InterApplicationBus.Channel.connect`.\n * * {@link OpenFin.ChannelProvider} describes a provider of a channel, e.g. as returned by `fin.InterApplicationBus.Channel.create`.\n *\n * @packageDocumentation\n */\nvar __classPrivateFieldSet$4 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar __classPrivateFieldGet$6 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar _Channel_connectionManager, _Channel_internalEmitter, _Channel_readyToConnect;\nObject.defineProperty(channel$1, \"__esModule\", { value: true });\nchannel$1.Channel = void 0;\n/* eslint-disable no-console */\nconst events_1$5 = require$$0;\nconst lazy_1$1 = lazy;\nconst base_1$e = base;\nconst client_1 = client;\nconst connection_manager_1 = connectionManager;\nconst provider_1 = provider;\nfunction retryDelay(count) {\n    const interval = 500; // base delay\n    const steps = 10; // How many retries to do before incrementing the delay\n    const base = 2; // How much to multiply the previous delay by\n    const max = 30000; // max delay\n    const step = Math.floor(count / steps);\n    const delay = Math.min(max, interval * base ** step);\n    return new Promise((resolve) => {\n        setTimeout(() => {\n            resolve(false);\n        }, delay);\n    });\n}\n/**\n * The Channel API allows an OpenFin application to create a channel as a {@link ChannelProvider ChannelProvider},\n * or connect to a channel as a {@link ChannelClient ChannelClient}.\n * @remarks The \"handshake\" between the communication partners is\n * simplified when using a channel.  A request to connect to a channel as a client will return a promise that resolves if/when the channel has been created. Both the\n * provider and client can dispatch actions that have been registered on their opposites, and dispatch returns a promise that resolves with a payload from the other\n * communication participant. There can be only one provider per channel, but many clients.  Version `9.61.35.*` or later is required for both communication partners.\n *\n * Asynchronous Methods:\n *  * {@link Channel.create create(channelName, options)}\n *  * {@link Channel.connect connect(channelName, options)}\n *  * {@link Channel.onChannelConnect onChannelConnect(listener)}\n *  * {@link Channel.onChannelDisconnect onChannelDisconnect(listener)}\n */\nclass Channel extends base_1$e.EmitterBase {\n    /**\n     * @internal\n     */\n    constructor(wire) {\n        super(wire, 'channel');\n        _Channel_connectionManager.set(this, void 0);\n        _Channel_internalEmitter.set(this, new events_1$5.EventEmitter());\n        // OpenFin API has not been injected at construction time, *must* wait for API to be ready.\n        _Channel_readyToConnect.set(this, new lazy_1$1.AsyncRetryableLazy(async () => {\n            await Promise.all([\n                this.on('disconnected', (eventPayload) => {\n                    client_1.ChannelClient.handleProviderDisconnect(eventPayload);\n                }),\n                this.on('connected', (...args) => {\n                    __classPrivateFieldGet$6(this, _Channel_internalEmitter, \"f\").emit('connected', ...args);\n                })\n            ]).catch(() => new Error('error setting up channel connection listeners'));\n        }));\n        __classPrivateFieldSet$4(this, _Channel_connectionManager, new connection_manager_1.ConnectionManager(wire), \"f\");\n    }\n    /**\n     *\n     * @internal\n     */\n    async getAllChannels() {\n        return this.wire.sendAction('get-all-channels').then(({ payload }) => payload.data);\n    }\n    /**\n     * Listens for channel connections.\n     *\n     * @param listener - callback to execute.\n     *\n     * @example\n     *\n     * ```js\n     * const listener = (channelPayload) => console.log(channelPayload); // see return value below\n     *\n     * fin.InterApplicationBus.Channel.onChannelConnect(listener);\n     *\n     * // example shape\n     * {\n     *     \"topic\": \"channel\",\n     *     \"type\": \"connected\",\n     *     \"uuid\": \"OpenfinPOC\",\n     *     \"name\": \"OpenfinPOC\",\n     *     \"channelName\": \"counter\",\n     *     \"channelId\": \"OpenfinPOC/OpenfinPOC/counter\"\n     * }\n     *\n     * ```\n     */\n    async onChannelConnect(listener) {\n        await this.on('connected', listener);\n    }\n    /**\n     * Listen for channel disconnections.\n     *\n     * @param listener - callback to execute.\n     *\n     * @example\n     *\n     * ```js\n     * const listener = (channelPayload) => console.log(channelPayload); // see return value below\n     *\n     * fin.InterApplicationBus.Channel.onChannelDisconnect(listener);\n     *\n     * // example shape\n     * {\n     *     \"topic\": \"channel\",\n     *     \"type\": \"disconnected\",\n     *     \"uuid\": \"OpenfinPOC\",\n     *     \"name\": \"OpenfinPOC\",\n     *     \"channelName\": \"counter\",\n     *     \"channelId\": \"OpenfinPOC/OpenfinPOC/counter\"\n     * }\n     *\n     * ```\n     */\n    async onChannelDisconnect(listener) {\n        await this.on('disconnected', listener);\n    }\n    async safeConnect(channelName, shouldWait, connectPayload) {\n        const retryInfo = { count: 0 };\n        /* eslint-disable no-await-in-loop, no-constant-condition */\n        do {\n            // setup a listener and a connected promise to await in case we connect before the channel is ready\n            let connectedListener = () => undefined;\n            const connectedPromise = new Promise((resolve) => {\n                connectedListener = (payload) => {\n                    if (channelName === payload.channelName) {\n                        resolve(true);\n                    }\n                };\n                __classPrivateFieldGet$6(this, _Channel_internalEmitter, \"f\").on('connected', connectedListener);\n            });\n            try {\n                if (retryInfo.count > 0) {\n                    // Wait before retrying\n                    // Delay returns false connectedPromise returns true so we can know if a retry is due to connected event\n                    retryInfo.gotConnectedEvent = await Promise.race([retryDelay(retryInfo.count), connectedPromise]);\n                    const result = await this.wire.sendAction('connect-to-channel', { ...connectPayload, retryInfo });\n                    // log only if there was a retry\n                    console.log(`Successfully connected to channelName: ${channelName}`);\n                    return result.payload.data;\n                }\n                // Send retryInfo to the core for debug log inclusion\n                const sentMessagePromise = this.wire.sendAction('connect-to-channel', connectPayload);\n                // Save messageId from the first connection attempt\n                retryInfo.originalMessageId = sentMessagePromise.messageId;\n                const result = await sentMessagePromise;\n                return result.payload.data;\n            }\n            catch (error) {\n                if (!error.message.includes('internal-nack')) {\n                    // Not an internal nack, break the loop\n                    throw error;\n                }\n                if (shouldWait && retryInfo.count === 0) {\n                    // start waiting on the next iteration, warn the user\n                    console.warn(`No channel found for channelName: ${channelName}. Waiting for connection...`);\n                }\n            }\n            finally {\n                retryInfo.count += 1;\n                // in case of other errors, remove our listener\n                __classPrivateFieldGet$6(this, _Channel_internalEmitter, \"f\").removeListener('connected', connectedListener);\n            }\n        } while (shouldWait); // If we're waiting we retry the above loop\n        // Should wait was false, no channel was found.\n        throw new Error(`No channel found for channelName: ${channelName}.`);\n        /* eslint-enable no-await-in-loop, no-constant-condition */\n    }\n    /**\n     * Connect to a channel. If you wish to send a payload to the provider, add a payload property to the options argument.\n     * EXPERIMENTAL: pass { protocols: ['rtc'] } as options to opt-in to High Throughput Channels.\n     *\n     * @param channelName - Name of the target channel.\n     * @param options - Connection options.\n     * @returns Returns a promise that resolves with an instance of {@link ChannelClient ChannelClient}.\n     *\n     * @remarks The connection request will be routed to the channelProvider if/when the channel is created.  If the connect\n     * request is sent prior to creation, the promise will not resolve or reject until the channel is created by a channelProvider\n     * (whether or not to wait for creation is configurable in the connectOptions).\n     *\n     * The connect call returns a promise that will resolve with a channelClient bus if accepted by the channelProvider, or reject if\n     * the channelProvider throws an error to reject the connection. This bus can communicate with the Provider, but not to other\n     * clients on the channel. Using the bus, the channelClient can register actions and middleware. Channel lifecycle can also be\n     * handled with an onDisconnection listener.\n     *\n     * @example\n     *\n     * ```js\n     * async function makeClient(channelName) {\n     *    // A payload can be sent along with channel connection requests to help with authentication\n     *    const connectPayload = { payload: 'token' };\n     *\n     *    // If the channel has been created this request will be sent to the provider.  If not, the\n     *    // promise will not be resolved or rejected until the channel has been created.\n     *    const clientBus = await fin.InterApplicationBus.Channel.connect(channelName, connectPayload);\n     *\n     *    clientBus.onDisconnection(channelInfo => {\n     *        // handle the channel lifecycle here - we can connect again which will return a promise\n     *        // that will resolve if/when the channel is re-created.\n     *        makeClient(channelInfo.channelName);\n     *    })\n     *\n     *    clientBus.register('topic', (payload, identity) => {\n     *        // register a callback for a topic to which the channel provider can dispatch an action\n     *        console.log('Action dispatched by provider: ', JSON.stringify(identity));\n     *        console.log('Payload sent in dispatch: ', JSON.stringify(payload));\n     *        return {\n     *            echo: payload\n     *        };\n     *    });\n     * }\n     *\n     * makeClient('channelName')\n     * .then(() => console.log('Connected'))\n     * .catch(console.error);\n     * ```\n     */\n    async connect(channelName, options = {}) {\n        // Make sure we don't connect before listeners are set up\n        // This also errors if we're not in OpenFin, ensuring we don't run unnecessary code\n        await __classPrivateFieldGet$6(this, _Channel_readyToConnect, \"f\").getValue();\n        if (!channelName || typeof channelName !== 'string') {\n            throw new Error('Please provide a channelName string to connect to a channel.');\n        }\n        const opts = { wait: true, ...this.wire.environment.getDefaultChannelOptions().connect, ...options };\n        const { offer, rtc: rtcPacket } = await __classPrivateFieldGet$6(this, _Channel_connectionManager, \"f\").createClientOffer(opts);\n        let connectionUrl;\n        if (this.fin.me.isFrame || this.fin.me.isView || this.fin.me.isWindow) {\n            connectionUrl = (await this.fin.me.getInfo()).url;\n        }\n        const connectPayload = {\n            channelName,\n            ...opts,\n            offer,\n            connectionUrl\n        };\n        const routingInfo = await this.safeConnect(channelName, opts.wait, connectPayload);\n        const strategy = await __classPrivateFieldGet$6(this, _Channel_connectionManager, \"f\").createClientStrategy(rtcPacket, routingInfo);\n        const channel = new client_1.ChannelClient(routingInfo, () => client_1.ChannelClient.wireClose(this.wire, routingInfo, routingInfo.endpointId), strategy);\n        // It is the client's responsibility to handle endpoint disconnection to the provider.\n        // If the endpoint dies, the client will force a disconnection through the core.\n        // The provider does not care about endpoint disconnection.\n        strategy.onEndpointDisconnect(routingInfo.channelId, async () => {\n            try {\n                await channel.sendDisconnectAction();\n            }\n            catch (error) {\n                console.warn(`Something went wrong during disconnect for client with uuid: ${routingInfo.uuid} / name: ${routingInfo.name} / endpointId: ${routingInfo.endpointId}.`);\n            }\n            finally {\n                client_1.ChannelClient.handleProviderDisconnect(routingInfo);\n            }\n        });\n        return channel;\n    }\n    /**\n     * Create a new channel.\n     * You must provide a unique channelName. If a channelName is not provided, or it is not unique, the creation will fail.\n     * EXPERIMENTAL: pass { protocols: ['rtc'] } as options to opt-in to High Throughput Channels.\n     *\n     * @param channelName - Name of the channel to be created.\n     * @param options - Creation options.\n     * @returns Returns a promise that resolves with an instance of {@link ChannelProvider ChannelProvider}.\n     *\n     * @remarks If successful, the create method returns a promise that resolves to an instance of the channelProvider bus. The caller\n     * then becomes the “channel provider” and can use the channelProvider bus to register actions and middleware.\n     *\n     * The caller can also set an onConnection and/or onDisconnection listener that will execute on any new channel\n     * connection/disconnection attempt from a channel client. To reject a connection, simply throw an error in the\n     * onConnection listener.  The default behavior is to accept all new connections.\n     *\n     * A map of client connections is updated automatically on client connection and disconnection and saved in the\n     * [read-only] `connections` property on the channelProvider bus.  The channel will exist until the provider\n     * destroys it or disconnects by closing or destroying the context (navigating or reloading). To setup a channel\n     * as a channelProvider, call `Channel.create` with a unique channel name. A map of client connections is updated\n     * automatically on client connection and disconnection.\n     *\n     * @example\n     *\n     * ```js\n     * (async ()=> {\n     *    // entity creates a channel and becomes the channelProvider\n     *    const providerBus = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *    providerBus.onConnection((identity, payload) => {\n     *        // can reject a connection here by throwing an error\n     *        console.log('Client connection request identity: ', JSON.stringify(identity));\n     *        console.log('Client connection request payload: ', JSON.stringify(payload));\n     *    });\n     *\n     *    providerBus.register('topic', (payload, identity) => {\n     *        // register a callback for a 'topic' to which clients can dispatch an action\n     *        console.log('Action dispatched by client: ', JSON.stringify(identity));\n     *        console.log('Payload sent in dispatch: ', JSON.stringify(payload));\n     *        return {\n     *            echo: payload\n     *        };\n     *    });\n     * })();\n     * ```\n     */\n    async create(channelName, options) {\n        if (!channelName) {\n            throw new Error('Please provide a channelName to create a channel');\n        }\n        const { payload: { data: providerIdentity } } = await this.wire.sendAction('create-channel', { channelName });\n        const channel = __classPrivateFieldGet$6(this, _Channel_connectionManager, \"f\").createProvider(options, providerIdentity);\n        // TODO: fix typing (internal)\n        // @ts-expect-error\n        this.on('client-disconnected', (eventPayload) => {\n            if (eventPayload.channelName === channelName) {\n                provider_1.ChannelProvider.handleClientDisconnection(channel, eventPayload);\n            }\n        });\n        return channel;\n    }\n}\nchannel$1.Channel = Channel;\n_Channel_connectionManager = new WeakMap(), _Channel_internalEmitter = new WeakMap(), _Channel_readyToConnect = new WeakMap();\n\nObject.defineProperty(interappbus, \"__esModule\", { value: true });\ninterappbus.InterAppPayload = interappbus.InterApplicationBus = void 0;\n/**\n * Entry point for the OpenFin `InterApplicationBus` API (`fin.InterApplicationBus`).\n *\n * * {@link InterApplicationBus} contains static members of the `InterApplicationBus` API, accessible through `fin.InterApplicationBus`.\n *\n * @packageDocumentation\n */\nconst events_1$4 = require$$0;\nconst base_1$d = base;\nconst ref_counter_1 = refCounter;\nconst index_1$2 = channel$1;\nconst validate_1$3 = validate;\n/**\n * A messaging bus that allows for pub/sub messaging between different applications.\n *\n */\nclass InterApplicationBus extends base_1$d.Base {\n    /**\n     * @internal\n     */\n    constructor(wire) {\n        super(wire);\n        this.events = {\n            subscriberAdded: 'subscriber-added',\n            subscriberRemoved: 'subscriber-removed'\n        };\n        this.refCounter = new ref_counter_1.RefCounter();\n        this.Channel = new index_1$2.Channel(wire);\n        this.emitter = new events_1$4.EventEmitter();\n        wire.registerMessageHandler(this.onmessage.bind(this));\n        this.on = this.emitter.on.bind(this.emitter);\n        this.removeAllListeners = this.emitter.removeAllListeners.bind(this.emitter);\n    }\n    /**\n     * Publishes a message to all applications running on OpenFin Runtime that\n     * are subscribed to the specified topic.\n     * @param topic The topic on which the message is sent\n     * @param message The message to be published. Can be either a primitive\n     * data type (string, number, or boolean) or composite data type (object, array)\n     * that is composed of other primitive or composite data types\n     *\n     * @example\n     * ```js\n     * fin.InterApplicationBus.publish('topic', 'hello').then(() => console.log('Published')).catch(err => console.log(err));\n     * ```\n     */\n    async publish(topic, message) {\n        await this.wire.sendAction('publish-message', {\n            topic,\n            message,\n            sourceWindowName: this.me.name\n        });\n    }\n    /**\n     * Sends a message to a specific application on a specific topic.\n     * @param destination The identity of the application to which the message is sent\n     * @param topic The topic on which the message is sent\n     * @param message The message to be sent. Can be either a primitive data\n     * type (string, number, or boolean) or composite data type (object, array) that\n     * is composed of other primitive or composite data types\n     *\n     * @example\n     * ```js\n     * fin.InterApplicationBus.send(fin.me, 'topic', 'Hello there!').then(() => console.log('Message sent')).catch(err => console.log(err));\n     * ```\n     */\n    async send(destination, topic, message) {\n        const errorMsg = (0, validate_1$3.validateIdentity)(destination);\n        if (errorMsg) {\n            throw new Error(errorMsg);\n        }\n        await this.wire.sendAction('send-message', {\n            destinationUuid: destination.uuid,\n            destinationWindowName: destination.name,\n            topic,\n            message,\n            sourceWindowName: this.me.name\n        });\n    }\n    /**\n     * Subscribes to messages from the specified application on the specified topic.\n     * @param source This object is described in the Identity in the typedef\n     * @param topic The topic on which the message is sent\n     * @param listener A function that is called when a message has\n     * been received. It is passed the message, uuid and name of the sending application.\n     * The message can be either a primitive data type (string, number, or boolean) or\n     * composite data type (object, array) that is composed of other primitive or composite\n     * data types\n     *\n     * @example\n     * ```js\n     * // subscribe to a specified application\n     * fin.InterApplicationBus.subscribe(fin.me, 'topic', sub_msg => console.log(sub_msg)).then(() => console.log('Subscribed to the specified application')).catch(err => console.log(err));\n     *\n     * // subscribe to wildcard\n     * fin.InterApplicationBus.subscribe({ uuid: '*' }, 'topic', sub_msg => console.log(sub_msg)).then(() => console.log('Subscribed to *')).catch(err => console.log(err));\n     * ```\n     */\n    subscribe(source, topic, listener) {\n        const subKey = this.createSubscriptionKey(source.uuid, source.name || '*', topic);\n        const sendSubscription = async () => {\n            await this.wire.sendAction('subscribe', {\n                sourceUuid: source.uuid,\n                sourceWindowName: source.name || '*',\n                topic,\n                destinationWindowName: this.me.name\n            });\n        };\n        const alreadySubscribed = () => {\n            return Promise.resolve();\n        };\n        this.emitter.on(subKey, listener);\n        return this.refCounter.actOnFirst(subKey, sendSubscription, alreadySubscribed);\n    }\n    /**\n     * Unsubscribes to messages from the specified application on the specified topic.\n     *\n     * @remarks If you are listening to all apps on a topic, (i.e you passed `{ uuid:'*' }` to the subscribe function)\n     * then you need to pass `{ uuid:'*' }` to unsubscribe as well. If you are listening to a specific application,\n     * (i.e you passed `{ uuid:'some_app' }` to the subscribe function) then you need to provide the same identifier to\n     * unsubscribe, unsubscribing to `*` on that same topic will not unhook your initial listener otherwise.\n     *\n     * @param source This object is described in the Identity in the typedef\n     * @param topic The topic on which the message is sent\n     * @param listener A callback previously registered with subscribe()\n     *\n     * @example\n     * ```js\n     * const listener = console.log;\n     *\n     * // If any application publishes a message on topic `foo`, our listener will be called.\n     * await fin.InterApplicationBus.subscribe({ uuid:'*' }, 'foo', listener)\n     *\n     * // When you want to unsubscribe, you need to specify the uuid of the app you'd like to\n     * // unsubscribe from (or `*`) and provide the same function you gave the subscribe function\n     * await fin.InterApplicationBus.unsubscribe({ uuid:'*' }, 'foo', listener)\n     * ```\n     */\n    unsubscribe(source, topic, listener) {\n        const sourceWindowName = source.name || '*';\n        const subKey = this.createSubscriptionKey(source.uuid, sourceWindowName, topic);\n        const sendUnsubscription = async () => {\n            await this.wire.sendAction('unsubscribe', {\n                sourceUuid: source.uuid,\n                sourceWindowName,\n                topic,\n                destinationWindowName: this.me.name\n            });\n        };\n        const dontSendUnsubscription = () => {\n            return new Promise((r) => r).then(() => undefined);\n        };\n        this.emitter.removeListener(subKey, listener);\n        return this.refCounter.actOnLast(subKey, sendUnsubscription, dontSendUnsubscription);\n    }\n    processMessage(message) {\n        const { payload: { message: payloadMessage, sourceWindowName, sourceUuid, topic } } = message;\n        const keys = [\n            this.createSubscriptionKey(sourceUuid, sourceWindowName, topic),\n            this.createSubscriptionKey(sourceUuid, '*', topic),\n            this.createSubscriptionKey('*', '*', topic)\n        ];\n        const idOfSender = { uuid: sourceUuid, name: sourceWindowName };\n        keys.forEach((key) => {\n            this.emitter.emit(key, payloadMessage, idOfSender);\n        });\n    }\n    emitSubscriverEvent(type, message) {\n        const { payload: { targetName: name, uuid, topic } } = message;\n        const payload = { name, uuid, topic };\n        this.emitter.emit(type, payload);\n    }\n    // eslint-disable-next-line class-methods-use-this\n    createSubscriptionKey(uuid, name, topic) {\n        const n = name || '*';\n        if (!(uuid && n && topic)) {\n            throw new Error('Missing uuid, name, or topic string');\n        }\n        return createKey(uuid, n, topic);\n    }\n    onmessage(message) {\n        const { action } = message;\n        switch (action) {\n            case 'process-message':\n                this.processMessage(message);\n                break;\n            case this.events.subscriberAdded:\n                this.emitSubscriverEvent(this.events.subscriberAdded, message);\n                break;\n            case this.events.subscriberRemoved:\n                this.emitSubscriverEvent(this.events.subscriberRemoved, message);\n                break;\n        }\n        return true;\n    }\n}\ninterappbus.InterApplicationBus = InterApplicationBus;\n/**\n * @internal\n */\nclass InterAppPayload {\n}\ninterappbus.InterAppPayload = InterAppPayload;\nfunction createKey(...toHash) {\n    return toHash\n        .map((item) => {\n        return Buffer.from(`${item}`).toString('base64');\n    })\n        .join('/');\n}\n\nvar clipboard = {};\n\n/**\n * Entry point for the OpenFin `Clipboard` API (`fin.Clipboard`).\n *\n * * {@link Clipboard} contains static members of the `Clipboard` API, accessible through `fin.Clipboard`.\n *\n * @packageDocumentation\n */\nObject.defineProperty(clipboard, \"__esModule\", { value: true });\nclipboard.Clipboard = void 0;\nconst base_1$c = base;\n/**\n * The Clipboard API allows reading and writing to the clipboard in multiple formats.\n *\n */\nclass Clipboard extends base_1$c.Base {\n    /**\n     * Writes data into the clipboard as plain text\n     * @param writeObj The object for writing data into the clipboard\n     *\n     * @example\n     * ```js\n     * fin.Clipboard.writeText({\n     *     data: 'hello, world'\n     * }).then(() => console.log('Text On clipboard')).catch(err => console.log(err));\n     * ```\n     */\n    async writeText(writeObj) {\n        await this.wire.sendAction('clipboard-write-text', writeObj);\n    }\n    /**\n     * Read the content of the clipboard as plain text\n     * @param type Clipboard Type defaults to 'clipboard', use 'selection' for linux\n     *\n     * @example\n     * ```js\n     * fin.Clipboard.readText().then(text => console.log(text)).catch(err => console.log(err));\n     * ```\n     */\n    async readText(type) {\n        // NOTE: When we start supporting linux, we could detect the OS and choose 'selection' automatically for the user\n        const { payload } = await this.wire.sendAction('clipboard-read-text', { type });\n        return payload.data;\n    }\n    /**\n     * Writes data into the clipboard as an Image\n     * @param writeRequest The object to write an image to the clipboard\n     *\n     * @example\n     * ```js\n     * fin.Clipboard.writeImage({\n     *   // raw base64 string, or dataURL of either data:image/png or data:image/jpeg type\n     *   image: '...'\n     * }).then(() => console.log('Image written to clipboard')).catch(err => console.log(err));\n     * ```\n     */\n    async writeImage(writeRequest) {\n        await this.wire.sendAction('clipboard-write-image', writeRequest);\n    }\n    /**\n     * Read the content of the clipboard as a base64 string or a dataURL based on the input parameter 'format', defaults to 'dataURL'\n     * @param readRequest Clipboard Read Image request with formatting options\n     *\n     * @example\n     * ```js\n     * // see TS type: OpenFin.ImageFormatOptions\n     *\n     * const pngOrDataURLOrBmpOptions = {\n     *     format: 'png', // can be: 'png' | 'dataURL' | 'bmp'\n     * };\n     *\n     * const jpgOptions = {\n     *     format: 'jpg',\n     *     quality: 80 // optional, if omitted defaults to 100\n     * };\n     *\n     * fin.Clipboard.readImage(pngOrDataURLOrBmpOptions)\n     *     .then(image => console.log('Image read from clipboard as PNG, DataURL or BMP', image))\n     *     .catch(err => console.log(err));\n     *\n     * fin.Clipboard.readImage(jpgOptions)\n     *     .then(image => console.log('Image read from clipboard as JPG', image))\n     *     .catch(err => console.log(err));\n     *\n     * // defaults to {format: 'dataURL'}\n     * fin.Clipboard.readImage()\n     *     .then(image => console.log('Image read from clipboard as DataURL', image))\n     *     .catch(err => console.log(err));\n     *\n     * ```\n     */\n    async readImage(readRequest = { format: 'dataURL' }) {\n        const { payload } = await this.wire.sendAction('clipboard-read-image', readRequest);\n        return payload.data;\n    }\n    /**\n     * Writes data into the clipboard as Html\n     * @param writeObj The object for writing data into the clipboard\n     *\n     * @example\n     * ```js\n     * fin.Clipboard.writeHtml({\n     *         data: '<h1>Hello, World!</h1>'\n     * }).then(() => console.log('HTML On clipboard')).catch(err => console.log(err));\n     * ```\n     */\n    async writeHtml(writeObj) {\n        await this.wire.sendAction('clipboard-write-html', writeObj);\n    }\n    /**\n     * Read the content of the clipboard as Html\n     * @param type Clipboard Type defaults to 'clipboard', use 'selection' for linux\n     *\n     * @example\n     * ```js\n     * fin.Clipboard.readHtml().then(html => console.log(html)).catch(err => console.log(err));\n     * ```\n     */\n    async readHtml(type) {\n        const { payload } = await this.wire.sendAction('clipboard-read-html', { type });\n        return payload.data;\n    }\n    /**\n     * Writes data into the clipboard as Rtf\n     * @param writeObj The object for writing data into the clipboard\n     *\n     * @example\n     * ```js\n     * fin.Clipboard.writeRtf({\n     *         data: 'some text goes here'\n     * }).then(() => console.log('RTF On clipboard')).catch(err => console.log(err));\n     * ```\n     */\n    async writeRtf(writeObj) {\n        await this.wire.sendAction('clipboard-write-rtf', writeObj);\n    }\n    /**\n     * Read the content of the clipboard as Rtf\n     * @param type Clipboard Type defaults to 'clipboard', use 'selection' for linux\n     *\n     * @example\n     *\n     * ```js\n     * const writeObj = {\n     *     data: 'some text goes here'\n     * };\n     * async function readRtf() {\n     *     await fin.Clipboard.writeRtf(writeObj);\n     *     return await fin.Clipboard.readRtf();\n     * }\n     * readRtf().then(rtf => console.log(rtf)).catch(err => console.log(err));\n     * ```\n     */\n    async readRtf(type) {\n        const { payload } = await this.wire.sendAction('clipboard-read-rtf', { type });\n        return payload.data;\n    }\n    /**\n     * Writes data into the clipboard\n     * @param writeObj The object for writing data into the clipboard\n     *\n     * @example\n     * ```js\n     * fin.Clipboard.write({\n     *   data: {\n     *     text: 'a',\n     *     html: 'b',\n     *     rtf: 'c',\n     *     // Can be either a base64 string, or a DataURL string. If using DataURL, the\n     *     // supported formats are `data:image/png[;base64],` and `data:image/jpeg[;base64],`.\n     *     // Using other image/<format> DataURLs will throw an Error.\n     *     image: '...'\n     *   }\n     * }).then(() => console.log('write data into clipboard')).catch(err => console.log(err));\n     * ```\n     */\n    async write(writeObj) {\n        await this.wire.sendAction('clipboard-write', writeObj);\n    }\n    /**\n     * Reads available formats for the clipboard type\n     * @param type Clipboard Type defaults to 'clipboard', use 'selection' for linux\n     *\n     * @example\n     * ```js\n     * fin.Clipboard.getAvailableFormats().then(formats => console.log(formats)).catch(err => console.log(err));\n     * ```\n     */\n    async getAvailableFormats(type) {\n        const { payload } = await this.wire.sendAction('clipboard-read-formats', { type });\n        return payload.data;\n    }\n}\nclipboard.Clipboard = Clipboard;\n\nvar externalApplication = {};\n\nvar Factory$5 = {};\n\nvar Instance$4 = {};\n\nObject.defineProperty(Instance$4, \"__esModule\", { value: true });\nInstance$4.ExternalApplication = void 0;\n/* eslint-disable import/prefer-default-export */\nconst base_1$b = base;\n/**\n * An ExternalApplication object representing native language adapter connections to the runtime. Allows\n * the developer to listen to {@link OpenFin.ExternalApplicationEvents external application events}.\n * Discovery of connections is provided by {@link System.System.getAllExternalApplications getAllExternalApplications}.</a>\n *\n * Processes that can be wrapped as `ExternalApplication`s include the following:\n * - Processes which have connected to an OpenFin runtime via an adapter\n * - Processes started via `System.launchExternalApplication`\n * - Processes monitored via `System.monitorExternalProcess`\n */\nclass ExternalApplication extends base_1$b.EmitterBase {\n    /**\n     * @internal\n     */\n    constructor(wire, identity) {\n        super(wire, 'external-application', identity.uuid);\n        this.identity = identity;\n    }\n    /**\n     * Retrieves information about the external application.\n     *\n     * @example\n     * ```js\n     * async function getInfo() {\n     *     const extApp = await fin.ExternalApplication.wrap('javaApp-uuid');\n     *     return await extApp.getInfo();\n     * }\n     * getInfo().then(info => console.log(info)).catch(err => console.log(err));\n     * ```\n     */\n    getInfo() {\n        return this.wire.sendAction('get-external-application-info', this.identity).then(({ payload }) => payload.data);\n    }\n}\nInstance$4.ExternalApplication = ExternalApplication;\n\nObject.defineProperty(Factory$5, \"__esModule\", { value: true });\nFactory$5.ExternalApplicationModule = void 0;\nconst base_1$a = base;\nconst Instance_1$4 = Instance$4;\n/**\n * Static namespace for OpenFin API methods that interact with the {@link ExternalApplication} class, available under `fin.ExternalApplication`.\n */\nclass ExternalApplicationModule extends base_1$a.Base {\n    /**\n     * Asynchronously returns an External Application object that represents an external application.\n     * <br>It is possible to wrap a process that does not yet exist, (for example, to listen for startup-related events)\n     * provided its uuid is already known.\n     * @param uuid The UUID of the external application to be wrapped\n     *\n     * @example\n     * ```js\n     * fin.ExternalApplication.wrap('javaApp-uuid');\n     * .then(extApp => console.log('wrapped external application'))\n     * .catch(err => console.log(err));\n     * ```\n     */\n    wrap(uuid) {\n        this.wire.sendAction('external-application-wrap').catch((e) => {\n            // we do not want to expose this error, just continue if this analytics-only call fails\n        });\n        return Promise.resolve(new Instance_1$4.ExternalApplication(this.wire, { uuid }));\n    }\n    /**\n     * Synchronously returns an External Application object that represents an external application.\n     * <br>It is possible to wrap a process that does not yet exist, (for example, to listen for startup-related events)\n     * provided its uuid is already known.\n     * @param uuid The UUID of the external application to be wrapped\n     *\n     * @example\n     * ```js\n     * const extApp = fin.ExternalApplication.wrapSync('javaApp-uuid');\n     * const info = await extApp.getInfo();\n     * console.log(info);\n     * ```\n     */\n    wrapSync(uuid) {\n        this.wire.sendAction('external-application-wrap-sync').catch((e) => {\n            // we do not want to expose this error, just continue if this analytics-only call fails\n        });\n        return new Instance_1$4.ExternalApplication(this.wire, { uuid });\n    }\n}\nFactory$5.ExternalApplicationModule = ExternalApplicationModule;\n\n(function (exports) {\n\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t    }\n\t    Object.defineProperty(o, k2, desc);\n\t}) : (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    o[k2] = m[k];\n\t}));\n\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t};\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t/**\n\t * Entry points for the OpenFin `ExternalApplication` API (`fin.ExternalApplication`).\n\t *\n\t * * {@link ExternalApplicationModule} contains static members of the `ExternalApplication` type, accessible through `fin.ExternalApplication`.\n\t * * {@link ExternalApplication} describes an instance of an OpenFin ExternalApplication, e.g. as returned by `fin.ExternalApplication.getCurrent`.\n\t *\n\t * These are separate code entities, and are documented separately.  In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/32.114.76.10/index.html),\n\t * both of these were documented on the same page.\n\t *\n\t * @packageDocumentation\n\t */\n\t__exportStar(Factory$5, exports);\n\t__exportStar(Instance$4, exports); \n} (externalApplication));\n\nvar frame = {};\n\nvar Factory$4 = {};\n\nvar Instance$3 = {};\n\nObject.defineProperty(Instance$3, \"__esModule\", { value: true });\nInstance$3._Frame = void 0;\n/* eslint-disable import/prefer-default-export */\nconst base_1$9 = base;\n/**\n * An iframe represents an embedded HTML page within a parent HTML page. Because this embedded page\n * has its own DOM and global JS context (which may or may not be linked to that of the parent depending\n * on if it is considered out of the root domain or not), it represents a unique endpoint as an OpenFin\n * connection. Iframes may be generated dynamically, or be present on initial page load and each non-CORS\n * iframe has the OpenFin API injected by default. It is possible to opt into cross-origin iframes having\n * the API by setting api.iframe.crossOriginInjection to true in a window's options. To block all iframes\n * from getting the API injected you can set api.frame.sameOriginInjection\n * to false <a href=\"Window.html#~options\" target=\"_blank\">({@link OpenFin.WindowCreationOptions see Window Options})</a>.\n *\n * To be able to directly address this context for eventing and messaging purposes, it needs a\n * unique uuid name pairing. For OpenFin applications and windows this is provided via a configuration\n * object in the form of a manifest URL or options object, but there is no configuration object for iframes.\n * Just as a call to window.open outside of our Window API returns a new window with a random GUID assigned\n * for the name, each iframe that has the API injected will be assigned a GUID as its name, the UUID will be\n * the same as the parent window's.\n *\n * The fin.Frame namespace represents a way to interact with `iframes` and facilitates the discovery of current context\n * (iframe or main window) as well as the ability to listen for {@link OpenFin.FrameEvents frame-specific events}.\n */\nclass _Frame extends base_1$9.EmitterBase {\n    /**\n     * @internal\n     */\n    constructor(wire, identity) {\n        super(wire, 'frame', identity.uuid, identity.name);\n        this.identity = identity;\n    }\n    /**\n     * Returns a frame info object for the represented frame.\n     *\n     * @example\n     * ```js\n     * async function getInfo() {\n     *     const frm = await fin.Frame.getCurrent();\n     *     return await frm.getInfo();\n     * }\n     * getInfo().then(info => console.log(info)).catch(err => console.log(err));\n     * ```\n     */\n    getInfo() {\n        return this.wire.sendAction('get-frame-info', this.identity).then(({ payload }) => payload.data);\n    }\n    /**\n     * Returns a frame info object representing the window that the referenced iframe is\n     * currently embedded in.\n     *\n     * @remarks If the frame is embedded in a view, this will return an invalid stub with empty fields.\n     *\n     * @example\n     * ```js\n     * async function getParentWindow() {\n     *     const frm = await fin.Frame.getCurrent();\n     *     return await frm.getParentWindow();\n     * }\n     * getParentWindow().then(winInfo => console.log(winInfo)).catch(err => console.log(err));\n     * ```\n     */\n    getParentWindow() {\n        return this.wire.sendAction('get-parent-window', this.identity).then(({ payload }) => payload.data);\n    }\n}\nInstance$3._Frame = _Frame;\n\nObject.defineProperty(Factory$4, \"__esModule\", { value: true });\nFactory$4._FrameModule = void 0;\nconst base_1$8 = base;\nconst validate_1$2 = validate;\nconst Instance_1$3 = Instance$3;\n/**\n * Static namespace for OpenFin API methods that interact with the {@link _Frame} class, available under `fin.Frame`.\n */\nclass _FrameModule extends base_1$8.Base {\n    /**\n     * Asynchronously returns an API handle for the given Frame identity.\n     *\n     * @remarks Wrapping a Frame identity that does not yet exist will *not* throw an error, and instead\n     * returns a stub object that cannot yet perform rendering tasks. This can be useful for plumbing eventing\n     * for a Frame throughout its entire lifecycle.\n     *\n     * @example\n     * ```js\n     * fin.Frame.wrap({ uuid: 'testFrame', name: 'testFrame' })\n     * .then(frm => console.log('wrapped frame'))\n     * .catch(err => console.log(err));\n     * ```\n     */\n    async wrap(identity) {\n        this.wire.sendAction('frame-wrap').catch((e) => {\n            // we do not want to expose this error, just continue if this analytics-only call fails\n        });\n        const errorMsg = (0, validate_1$2.validateIdentity)(identity);\n        if (errorMsg) {\n            throw new Error(errorMsg);\n        }\n        return new Instance_1$3._Frame(this.wire, identity);\n    }\n    /**\n     * Synchronously returns an API handle for the given Frame identity.\n     *\n     * @remarks Wrapping a Frame identity that does not yet exist will *not* throw an error, and instead\n     * returns a stub object that cannot yet perform rendering tasks. This can be useful for plumbing eventing\n     * for a Frame throughout its entire lifecycle.\n     *\n     * @example\n     * ```js\n     * const frm = fin.Frame.wrapSync({ uuid: 'testFrame', name: 'testFrame' });\n     * const info = await frm.getInfo();\n     * console.log(info);\n     * ```\n     */\n    wrapSync(identity) {\n        this.wire.sendAction('frame-wrap-sync').catch((e) => {\n            // we do not want to expose this error, just continue if this analytics-only call fails\n        });\n        const errorMsg = (0, validate_1$2.validateIdentity)(identity);\n        if (errorMsg) {\n            throw new Error(errorMsg);\n        }\n        return new Instance_1$3._Frame(this.wire, identity);\n    }\n    /**\n     * Asynchronously returns a reference to the current frame\n     *\n     * @example\n     * ```js\n     * fin.Frame.getCurrent()\n     * .then(frm => console.log('current frame'))\n     * .catch(err => console.log(err));\n     * ```\n     */\n    getCurrent() {\n        this.wire.sendAction('frame-get-current').catch((e) => {\n            // we do not want to expose this error, just continue if this analytics-only call fails\n        });\n        return Promise.resolve(new Instance_1$3._Frame(this.wire, this.wire.environment.getCurrentEntityIdentity()));\n    }\n    /**\n     * Synchronously returns a reference to the current frame\n     *\n     * @example\n     * ```js\n     * const frm = fin.Frame.getCurrentSync();\n     * const info = await frm.getInfo();\n     * console.log(info);\n     * ```\n     */\n    getCurrentSync() {\n        this.wire.sendAction('frame-get-current-sync').catch((e) => {\n            // we do not want to expose this error, just continue if this analytics-only call fails\n        });\n        return new Instance_1$3._Frame(this.wire, this.wire.environment.getCurrentEntityIdentity());\n    }\n}\nFactory$4._FrameModule = _FrameModule;\n\n(function (exports) {\n\t/**\n\t * Entry points for the OpenFin `Frame` API (`fin.Frame`).\n\t *\n\t * * {@link _FrameModule} contains static members of the `Frame` API, accessible through `fin.Frame`.\n\t * * {@link _Frame} describes an instance of an OpenFin Frame, e.g. as returned by `fin.Frame.getCurrent`.\n\t *\n\t * These are separate code entities, and are documented separately. In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/32.114.76.10/index.html),\n\t * both of these were documented on the same page.\n\t *\n\t * Underscore prefixing of OpenFin types that alias DOM entities will be fixed in a future version.\n\t *\n\t * @packageDocumentation\n\t */\n\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t    }\n\t    Object.defineProperty(o, k2, desc);\n\t}) : (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    o[k2] = m[k];\n\t}));\n\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t};\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t__exportStar(Factory$4, exports);\n\t__exportStar(Instance$3, exports); \n} (frame));\n\nvar globalHotkey = {};\n\nObject.defineProperty(globalHotkey, \"__esModule\", { value: true });\nglobalHotkey.GlobalHotkey = void 0;\nconst base_1$7 = base;\n/**\n * The GlobalHotkey module can register/unregister a global hotkeys.\n *\n */\nclass GlobalHotkey extends base_1$7.EmitterBase {\n    /**\n     * @internal\n     */\n    constructor(wire) {\n        super(wire, 'global-hotkey');\n    }\n    /**\n     * Registers a global hotkey with the operating system.\n     * @param hotkey a hotkey string\n     * @param listener called when the registered hotkey is pressed by the user.\n     * @throws If the `hotkey` is reserved, see list below.\n     * @throws if the `hotkey` is already registered by another application.\n     *\n     * @remarks The `hotkey` parameter expects an electron compatible [accelerator](https://github.com/electron/electron/blob/master/docs/api/accelerator.md) and the `listener` will be called if the `hotkey` is pressed by the user.\n     * If successfull, the hotkey will be 'claimed' by the application, meaning that this register call can be called multiple times from within the same application but will fail if another application has registered the hotkey.\n     * <br>The register call will fail if given any of these reserved Hotkeys:\n     * * `CommandOrControl+0`\n     * * `CommandOrControl+=`\n     * * `CommandOrControl+Plus`\n     * * `CommandOrControl+-`\n     * * `CommandOrControl+_`\n     * * `CommandOrControl+Shift+I`\n     * * `F5`\n     * * `CommandOrControl+R`\n     * * `Shift+F5`\n     * * `CommandOrControl+Shift+R`\n     *\n     * Raises the `registered` event.\n     *\n     * @example\n     * ```js\n     * const hotkey = 'CommandOrControl+X';\n     *\n     * fin.GlobalHotkey.register(hotkey, () => {\n     * console.log(`${hotkey} pressed`);\n     * })\n     * .then(() => {\n     *     console.log('Success');\n     * })\n     * .catch(err => {\n     *     console.log('Error registering the hotkey', err);\n     * });\n     * ```\n     */\n    async register(hotkey, listener) {\n        // TODO: fix typing (hotkey events are not typed)\n        // @ts-expect-error\n        await this.on(hotkey, listener);\n        await this.wire.sendAction('global-hotkey-register', { hotkey });\n        return undefined;\n    }\n    /**\n     * Unregisters a global hotkey with the operating system.\n     * @param hotkey a hotkey string\n     *\n     * @remarks This method will unregister all existing registrations of the hotkey within the application.\n     * Raises the `unregistered` event.\n     *\n     * @example\n     * ```js\n     * const hotkey = 'CommandOrControl+X';\n     *\n     * fin.GlobalHotkey.unregister(hotkey)\n     * .then(() => {\n     *     console.log('Success');\n     * })\n     * .catch(err => {\n     *     console.log('Error unregistering the hotkey', err);\n     * });\n     * ```\n     */\n    async unregister(hotkey) {\n        // TODO: fix typing (hotkey events are not typed)\n        // @ts-expect-error\n        await this.removeAllListeners(hotkey);\n        await this.wire.sendAction('global-hotkey-unregister', { hotkey });\n        return undefined;\n    }\n    /**\n     * Unregisters all global hotkeys for the current application.\n     *\n     * @remarks Raises the `unregistered` event for each hotkey unregistered.\n     *\n     * @example\n     * ```js\n     * fin.GlobalHotkey.unregisterAll()\n     * .then(() => {\n     *     console.log('Success');\n     * })\n     * .catch(err => {\n     *     console.log('Error unregistering all hotkeys for this application', err);\n     * });\n     * ```\n     */\n    async unregisterAll() {\n        await Promise.all(this.eventNames()\n            .filter((name) => !(name === 'registered' || name === 'unregistered'))\n            // TODO: fix typing (hotkey events are not typed)\n            // @ts-expect-error\n            .map((name) => this.removeAllListeners(name)));\n        await this.wire.sendAction('global-hotkey-unregister-all', {});\n        return undefined;\n    }\n    /**\n     * Checks if a given hotkey has been registered by an application within the current runtime.\n     * @param hotkey a hotkey string\n     *\n     * @example\n     * ```js\n     * const hotkey = 'CommandOrControl+X';\n     *\n     * fin.GlobalHotkey.isRegistered(hotkey)\n     * .then((registered) => {\n     *     console.log(`hotkey ${hotkey} is registered ? ${registered}`);\n     * })\n     * .catch(err => {\n     *     console.log('Error unregistering the hotkey', err);\n     * });\n     * ```\n     */\n    async isRegistered(hotkey) {\n        const { payload: { data } } = await this.wire.sendAction('global-hotkey-is-registered', { hotkey });\n        return data;\n    }\n}\nglobalHotkey.GlobalHotkey = GlobalHotkey;\n\nvar platform = {};\n\nvar Factory$3 = {};\n\nvar Instance$2 = {};\n\nvar __classPrivateFieldGet$5 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar _Platform_connectToProvider;\nObject.defineProperty(Instance$2, \"__esModule\", { value: true });\nInstance$2.Platform = void 0;\n/* eslint-disable import/prefer-default-export, no-undef */\nconst base_1$6 = base;\nconst validate_1$1 = validate;\n// Reuse clients to avoid overwriting already-registered client in provider\nconst clientMap = new Map();\n/** Manages the life cycle of windows and views in the application.\n *\n * Enables taking snapshots of itself and applying them to restore a previous configuration\n * as well as listen to {@link OpenFin.PlatformEvents platform events}.\n */\nclass Platform extends base_1$6.EmitterBase {\n    /**\n     * @internal\n     */\n    // eslint-disable-next-line no-shadow\n    constructor(identity, channel) {\n        // we piggyback off of application event emitter because from the core's perspective platform is just an app.\n        super(channel.wire, 'application', identity.uuid);\n        this.getClient = (identity) => {\n            this.wire.sendAction('platform-get-client', this.identity).catch((e) => {\n                // don't expose\n            });\n            const target = identity || this.identity;\n            const { uuid } = target;\n            if (!clientMap.has(uuid)) {\n                const clientPromise = __classPrivateFieldGet$5(this, _Platform_connectToProvider, \"f\").call(this, uuid);\n                clientMap.set(uuid, clientPromise);\n            }\n            // we set it above\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            return clientMap.get(uuid);\n        };\n        _Platform_connectToProvider.set(this, async (uuid) => {\n            try {\n                const channelName = `custom-frame-${uuid}`;\n                const client = await this._channel.connect(channelName, { wait: false });\n                client.onDisconnection(() => {\n                    clientMap.delete(uuid);\n                });\n                return client;\n            }\n            catch (e) {\n                clientMap.delete(uuid);\n                throw new Error('The targeted Platform is not currently running. Listen for application-started event for the given Uuid.');\n            }\n        });\n        /**\n         * @deprecated (renamed)\n         * @ignore\n         */\n        this.launchLegacyManifest = this.launchContentManifest;\n        const errorMsg = (0, validate_1$1.validateIdentity)(identity);\n        if (errorMsg) {\n            throw new Error(errorMsg);\n        }\n        this._channel = channel;\n        this.identity = { uuid: identity.uuid };\n        this.Layout = this.fin.Platform.Layout;\n        this.Application = this.fin.Application.wrapSync(this.identity);\n    }\n    /**\n     * Creates a new view and attaches it to a specified target window.\n     * @param viewOptions View creation options\n     * @param target The window to which the new view is to be attached. If no target, create a view in a new window.\n     * @param targetView If provided, the new view will be added to the same tabstrip as targetView.\n     *\n     * @remarks If the view already exists, will reparent the view to the new target. You do not need to set a name for a View.\n     * Views that are not passed a name get a randomly generated one.\n     *\n     * @example\n     * ```js\n     * let windowIdentity;\n     * if (fin.me.isWindow) {\n     *     windowIdentity = fin.me.identity;\n     * } else if (fin.me.isView) {\n     *     windowIdentity = (await fin.me.getCurrentWindow()).identity;\n     * } else {\n     *     throw new Error('Not running in a platform View or Window');\n     * }\n     *\n     * const platform = fin.Platform.getCurrentSync();\n     *\n     * platform.createView({\n     *     name: 'test_view',\n     *     url: 'https://developers.openfin.co/docs/platform-api'\n     * }, windowIdentity).then(console.log);\n     * ```\n     *\n     * Reparenting a view:\n     * ```js\n     * let windowIdentity;\n     * if (fin.me.isWindow) {\n     *     windowIdentity = fin.me.identity;\n     * } else if (fin.me.isView) {\n     *     windowIdentity = (await fin.me.getCurrentWindow()).identity;\n     * } else {\n     *     throw new Error('Not running in a platform View or Window');\n     * }\n     *\n     * let platform = fin.Platform.getCurrentSync();\n     * let viewOptions = {\n     *     name: 'example_view',\n     *     url: 'https://example.com'\n     * };\n     * // a new view will now show in the current window\n     * await platform.createView(viewOptions, windowIdentity);\n     *\n     * const view = fin.View.wrapSync({ uuid: windowIdentity.uuid, name: 'yahoo_view' });\n     * // reparent `example_view` when a view in the new window is shown\n     * view.on('shown', async () => {\n     *     let viewIdentity = { uuid: windowIdentity.uuid, name: 'example_view'};\n     *     let target = {uuid: windowIdentity.uuid, name: 'test_win'};\n     *     platform.createView(viewOptions, target);\n     * });\n     *\n     * // create a new window\n     * await platform.createWindow({\n     *     name: \"test_win\",\n     *     layout: {\n     *         content: [\n     *             {\n     *                 type: 'stack',\n     *                 content: [\n     *                     {\n     *                         type: 'component',\n     *                         componentName: 'view',\n     *                         componentState: {\n     *                             name: 'yahoo_view',\n     *                             url: 'https://yahoo.com'\n     *                         }\n     *                     }\n     *                 ]\n     *             }\n     *         ]\n     *     }\n     * }).then(console.log);\n     * ```\n     */\n    async createView(viewOptions, target, targetView) {\n        this.wire.sendAction('platform-create-view', this.identity).catch((e) => {\n            // don't expose\n        });\n        const client = await this.getClient();\n        const response = await client.dispatch('create-view', {\n            target,\n            opts: viewOptions,\n            targetView\n        });\n        if (!response || (0, validate_1$1.validateIdentity)(response.identity)) {\n            throw new Error(`When overwriting the createView call, please return an object that has a valid 'identity' property: ${JSON.stringify(response)}`);\n        }\n        return this.fin.View.wrapSync(response.identity);\n    }\n    /**\n     * Creates a new Window.\n     * @param options Window creation options\n     *\n     * @remarks There are two Window types at your disposal while using OpenFin Platforms - Default Window and Custom Window.\n     *\n     * The Default Window uses the standard OpenFin Window UI. It contains the standard close, maximize and minimize buttons,\n     * and will automatically render the Window's layout if one is specified.\n     *\n     * For deeper customization, you can bring your own Window code into a Platform. This is called a Custom Window.\n     *\n     * @example\n     *\n     *\n     * The example below will create a Default Window which uses OpenFin default Window UI.<br>\n     * The Window contains two Views in a stack Layout:\n     *\n     * ```js\n     * const platform = fin.Platform.getCurrentSync();\n     * platform.createWindow({\n     *     layout: {\n     *         content: [\n     *             {\n     *                 type: 'stack',\n     *                 content: [\n     *                     {\n     *                         type: 'component',\n     *                         componentName: 'view',\n     *                         componentState: {\n     *                             name: 'test_view_1',\n     *                             url: 'https://cdn.openfin.co/docs/javascript/canary/Platform.html'\n     *                         }\n     *                     },\n     *                     {\n     *                         type: 'component',\n     *                         componentName: 'view',\n     *                         componentState: {\n     *                             name: 'test_view_2',\n     *                             url: 'https://cdn.openfin.co/docs/javascript/canary/Platform.html'\n     *                         }\n     *                     }\n     *                 ]\n     *             }\n     *         ]\n     *     }\n     * }).then(console.log);\n     * ```\n     * The Default Window's design can be customized by specifying the `stylesheetUrl` property in the manifest:\n     *\n     * ```json\n     * {\n     *     platform: {\n     *         defaultWindowOptions: {\n     *             stylesheetUrl: 'some-url.css',\n     *             ...\n     *         }\n     *     }\n     * }\n     * ```\n     * For a list of common Layout CSS classes you can override in your custom stylesheet, see <a href=\"tutorial-layoutStyles.html\">Useful Layout CSS Classes</a>\n     **\n     * To specify a Platform Custom Window, provide a `url` property when creating a Window.\n     * If you intend to render a Layout in your Custom Window, you must also specify an `HTMLElement` that the Layout will inject into and set its `id` property to `\"layout-container\"`.\n     *\n     * The example below will create a Platform Custom Window:\n     *\n     * ```js\n     *     // in an OpenFin app:\n     *     const platform = fin.Platform.getCurrentSync();\n     *     const windowConfig =\n     *         {\n     *             url: \"https://www.my-domain.com/my-custom-window.html\", // here we point to where the Custom Frame is hosted.\n     *             layout: {\n     *                 content: [\n     *                     {\n     *                         type: \"stack\",\n     *                         content: [\n     *                             {\n     *                                 type: \"component\",\n     *                                 componentName: \"view\",\n     *                                 componentState: {\n     *                                     name: \"app #1\",\n     *                                     url: \"https://cdn.openfin.co/docs/javascript/canary/Platform.html\"\n     *                                 }\n     *                             },\n     *                             {\n     *                                 type: \"component\",\n     *                                 componentName: \"view\",\n     *                                 componentState: {\n     *                                     name: \"app #2\",\n     *                                     url: \"https://cdn.openfin.co/docs/javascript/canary/Platform.html\"\n     *                                 }\n     *                             }\n     *                         ]\n     *                     }\n     *                 ]\n     *             }\n     *         };\n     *     platform.createWindow(windowConfig);\n     * ```\n     *\n     * Here's an example of a minimalist Custom Platform Window implementation:\n     * ```html\n     * <html>\n     *     <head>\n     *         <meta charset=\"utf-8\">\n     *         <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n     *         <link rel=\"stylesheet\" type=\"text/css\" href=\"./styles.css\">\n     *     </head>\n     *     <body>\n     *         <div id=\"of-frame-main\">\n     *             <div id=\"title-bar\">\n     *                 <div class=\"title-bar-draggable\">\n     *                     <div id=\"title\"> This is a custom frame! </div>\n     *                 </div>\n     *                 <div id=\"buttons-wrapper\">\n     *                     <div class=\"button\" id=\"minimize-button\"></div>\n     *                     <div class=\"button\" id=\"expand-button\"></div>\n     *                     <div class=\"button\" id=\"close-button\"></div>\n     *                 </div>\n     *             </div>\n     *             <div id=\"layout-container\"></div> <!-- OpenFin layout would be injected here -->\n     *             <script src=\"./custom-frame.js\"></script>\n     *         </div>\n     *     </body>\n     * </html>\n     * ```\n     * Your Custom Window can use in-domain resources for further customization (such as CSS, scripts, etc.).<br>\n     * For a list of common Layout CSS classes you can override in your stylesheet, see <a href=\"tutorial-layoutStyles.html\">Useful Layout CSS Classes</a>\n     *\n     * The example above will require the `body` element to have `height: 100%;` set in order to render the layout correctly.\n     */\n    async createWindow(options) {\n        this.wire.sendAction('platform-create-window', this.identity).catch((e) => {\n            // don't expose\n        });\n        const client = await this.getClient();\n        if (!options.reason) {\n            options.reason = 'api-call';\n        }\n        const response = await client.dispatch('create-view-container', options);\n        if (!response || (0, validate_1$1.validateIdentity)(response.identity)) {\n            throw new Error(`When overwriting the createWindow call, please return an object that has a valid 'identity' property: ${JSON.stringify(response)}`);\n        }\n        const { identity } = response;\n        const res = this.fin.Window.wrapSync(identity);\n        // we add the identity at the top level for backwards compatibility.\n        res.name = identity.name;\n        res.uuid = identity.uuid;\n        return res;\n    }\n    /**\n     * Closes current platform, all its windows, and their views.\n     *\n     * @example\n     * ```js\n     * const platform = await fin.Platform.getCurrent();\n     * platform.quit();\n     * // All windows/views in current layout platform will close and platform will shut down\n     * ```\n     */\n    async quit() {\n        this.wire.sendAction('platform-quit', this.identity).catch((e) => {\n            // don't expose\n        });\n        const client = await this.getClient();\n        return client.dispatch('quit');\n    }\n    /**\n     * Closes a specified view in a target window.\n     * @param viewIdentity View identity\n     *\n     * @example\n     * ```js\n     * let windowIdentity;\n     * if (fin.me.isWindow) {\n     *     windowIdentity = fin.me.identity;\n     * } else if (fin.me.isView) {\n     *     windowIdentity = (await fin.me.getCurrentWindow()).identity;\n     * } else {\n     *     throw new Error('Not running in a platform View or Window');\n     * }\n     *\n     * const viewOptions = {\n     *     name: 'test_view',\n     *     url: 'https://example.com'\n     * };\n     *\n     * function sleep(ms) {\n     *     return new Promise(resolve => setTimeout(resolve, ms));\n     * }\n     *\n     * const platform = await fin.Platform.getCurrent();\n     *\n     * await platform.createView(viewOptions, windowIdentity);\n     * // a new view will now show in the current window\n     *\n     * await sleep(5000);\n     *\n     * const viewIdentity = { uuid: windowIdentity.uuid, name: 'test_view'};\n     * platform.closeView(viewIdentity);\n     * // the view will now close\n     * ```\n     */\n    async closeView(viewIdentity) {\n        this.wire.sendAction('platform-close-view', this.identity).catch((e) => {\n            // don't expose\n        });\n        const client = await this.getClient();\n        await client.dispatch('close-view', {\n            view: viewIdentity\n        });\n    }\n    /**\n     * ***DEPRECATED - please use {@link Platform.createView Platform.createView}.***\n     * Reparents a specified view in a new target window.\n     * @param viewIdentity View identity\n     * @param target new owner window identity\n     *\n     */\n    async reparentView(viewIdentity, target) {\n        // eslint-disable-next-line no-console\n        console.warn('Platform.reparentView has been deprecated, please use Platform.createView');\n        this.wire.sendAction('platform-reparent-view', this.identity).catch((e) => {\n            // don't expose\n        });\n        const normalizedViewIdentity = {\n            ...viewIdentity,\n            uuid: viewIdentity.uuid ?? this.identity.uuid\n        };\n        const view = await this.fin.View.wrap(normalizedViewIdentity);\n        const viewOptions = await view.getOptions();\n        return this.createView(viewOptions, target);\n    }\n    /**\n     * Returns a snapshot of the platform in its current state. You can pass the returning object to\n     * [Platform.applySnapshot]{@link Platform#applySnapshot} to launch it.\n     *\n     * @remarks The snapshot will include details such as an [ISO format](https://en.wikipedia.org/wiki/ISO_8601)\n     * timestamp of when the snapshot was taken, OpenFin runtime version the platform is running on, monitor information\n     * and the list of currently running windows.\n     *\n     * @example\n     * ```js\n     * const platform = await fin.Platform.getCurrent();\n     * const snapshot = await platform.getSnapshot();\n     * ```\n     */\n    async getSnapshot() {\n        this.wire.sendAction('platform-get-snapshot', this.identity).catch((e) => {\n            // don't expose\n        });\n        const client = await this.getClient();\n        return client.dispatch('get-snapshot');\n    }\n    /**\n     * **NOTE**: Internal use only. It is not recommended to manage the state of individual views.\n     *\n     * Returns a snapshot of a single view's options in its current state.\n     *\n     * Can be used to restore a view to a previous state.\n     *\n     * @param viewIdentity View identity\n     *\n     * @internal\n     * @experimental\n     * @remarks This slice of snapshot state is equivalent to what is stored as `componentState` for views\n     * when capturing platform state using [Platform.getSnapshot]{@link Platform#getSnapshot}.\n     *\n     * @example\n     * ```js\n     * const platform = await fin.Platform.getCurrent();\n     * const url = 'https://google.com';\n     * const view = await fin.View.create({ name: 'my-view', target: fin.me.identity, url });\n     *\n     * await view.navigate(url);\n     *\n     * const viewState = await platform.getViewSnapshot(view.identity);\n     *\n     * console.log(viewState);\n     * ```\n     */\n    async getViewSnapshot(viewIdentity) {\n        const client = await this.getClient();\n        return client.dispatch('get-view-snapshot', { viewIdentity });\n    }\n    /**\n     * Adds a snapshot to a running Platform.\n     * Requested snapshot must be a valid Snapshot object, or a url or filepath to such an object.\n     *\n     * Can optionally close existing windows and overwrite current platform state with that of a snapshot.\n     *\n     * The function accepts either a snapshot taken using {@link Platform#getSnapshot getSnapshot},\n     * or a url or filepath to a snapshot JSON object.\n     * @param requestedSnapshot Snapshot to apply, or a url or filepath.\n     * @param options Optional parameters to specify whether existing windows should be closed.\n     *\n     * @remarks Will create any windows and views that are not running but are passed in the snapshot object. Any View\n     * specified in the snapshot is assigned a randomly generated name to avoid collisions.\n     *\n     * @example\n     * ```js\n     * // Get a wrapped layout platform instance\n     * const platform = await fin.Platform.getCurrent();\n     *\n     * const snapshot = {\n     *     windows: [\n     *         {\n     *             layout: {\n     *                 content: [\n     *                     {\n     *                         type: 'stack',\n     *                         content: [\n     *                             {\n     *                                 type: 'component',\n     *                                 componentName: 'view',\n     *                                 componentState: {\n     *                                     name: 'component_X',\n     *                                     url: 'https://www.openfin.co'\n     *                                 }\n     *                             },\n     *                             {\n     *                                 type: 'component',\n     *                                 componentName: 'view',\n     *                                 componentState: {\n     *                                     name: 'component_Y',\n     *                                     url: 'https://cdn.openfin.co/embed-web/chart.html'\n     *                                 }\n     *                             }\n     *                         ]\n     *                     }\n     *                 ]\n     *             }\n     *         }\n     *     ]\n     * }\n     *\n     * platform.applySnapshot(snapshot);\n     * ```\n     *\n     * In place of a snapshot object, `applySnapshot` can take a url or filepath and to retrieve a JSON snapshot.\n     *\n     * ```js\n     * const platform = await fin.Platform.getCurrent();\n     * platform.applySnapshot('https://api.jsonbin.io/b/5e6f903ef4331e681fc1231d/1');\n     * ```\n     *\n     * Optionally, `applySnapshot` can close existing windows and restore a Platform to a previously saved state.\n     * This is accomplished by providing `{ closeExistingWindows: true }` as an option.\n     *\n     * ```js\n     * // Get a wrapped layout platform instance\n     * const platform = await fin.Platform.getCurrent();\n     *\n     * async function addViewToWindow(winId) {\n     *     return await platform.createView({\n     *         name: 'test_view_3',\n     *         url: 'https://openfin.co'\n     *     }, winId);\n     * }\n     *\n     * async function createWindowWithTwoViews() {\n     *     const platform = await fin.Platform.getCurrent();\n     *\n     *     return platform.createWindow({\n     *         layout: {\n     *             content: [\n     *                 {\n     *                     type: 'stack',\n     *                     content: [\n     *                         {\n     *                             type: 'component',\n     *                             componentName: 'view',\n     *                             componentState: {\n     *                                 name: 'test_view_1',\n     *                                 url: 'https://example.com'\n     *                             }\n     *                         },\n     *                         {\n     *                             type: 'component',\n     *                             componentName: 'view',\n     *                             componentState: {\n     *                                 name: 'test_view_2',\n     *                                 url: 'https://yahoo.com'\n     *                             }\n     *                         }\n     *                     ]\n     *                 }\n     *             ]\n     *         }\n     *     });\n     * }\n     *\n     * const win = await createWindowWithTwoViews();\n     * // ... you will now see a new window with two views in it\n     *\n     * // we take a snapshot of the current state of the app, before changing it\n     * const snapshotOfInitialAppState = await platform.getSnapshot();\n     *\n     * // now let's change the state of the app:\n     * await addViewToWindow(win.identity);\n     * // ... the window now has three views in it\n     *\n     * await platform.applySnapshot(snapshotOfInitialAppState, { closeExistingWindows: true });\n     * // ... the window will revert to previous state, with just two views\n     *\n     * ```\n     */\n    async applySnapshot(requestedSnapshot, options) {\n        this.wire.sendAction('platform-apply-snapshot', this.identity).catch((e) => {\n            // don't expose\n        });\n        const errMsg = 'Requested snapshot must be a valid Snapshot object, or a url or filepath to such an object.';\n        let snapshot;\n        if (typeof requestedSnapshot === 'string') {\n            // Fetch and parse snapshot\n            try {\n                const response = await this._channel.wire.sendAction('get-application-manifest', {\n                    manifestUrl: requestedSnapshot\n                });\n                snapshot = response.payload.data;\n            }\n            catch (err) {\n                throw new Error(`${errMsg}: ${err}`);\n            }\n        }\n        else {\n            snapshot = requestedSnapshot;\n        }\n        if (!snapshot.windows) {\n            throw new Error(errMsg);\n        }\n        const client = await this.getClient();\n        await client.dispatch('apply-snapshot', {\n            snapshot,\n            options\n        });\n        return this;\n    }\n    /**\n     * Fetches a JSON manifest using the browser process and returns a Javascript object.\n     * Can be overwritten using {@link Platform.PlatformModule.init Platform.init}.\n     * @param manifestUrl The URL of the manifest to fetch.\n     *\n     * @remarks Can be overwritten using {@link Platform#init Platform.init}.\n     *\n     * @example\n     *\n     * ```js\n     * const platform = fin.Platform.getCurrentSync();\n     * const manifest = await platform.fetchManifest('https://www.path-to-manifest.com/app.json');\n     * console.log(manifest);\n     * ```\n     */\n    async fetchManifest(manifestUrl) {\n        const client = await this.getClient();\n        return client.dispatch('platform-fetch-manifest', { manifestUrl });\n    }\n    /**\n     * Retrieves a manifest by url and launches a legacy application manifest or snapshot into the platform.  Returns a promise that\n     * resolves to the wrapped Platform.\n     * @param manifestUrl - The URL of the manifest that will be launched into the platform.  If this app manifest\n     * contains a snapshot, that will be launched into the platform.  If not, the application described in startup_app options\n     * will be launched into the platform. The applicable startup_app options will become {@link OpenFin.ViewCreationOptions View Options}.\n     *\n     * @remarks If the app manifest contains a snapshot, that will be launched into the platform.  If not, the\n     * application described in startup_app options will be launched into the platform as a window with a single view.\n     * The applicable startup_app options will become View Options.\n     *\n     * @example\n     * ```js\n     * try {\n     *     const platform = fin.Platform.getCurrentSync();\n     *     await platform.launchContentManifest('http://localhost:5555/app.json');\n     *     console.log(`content launched successfully into platform`);\n     * } catch(e) {\n     *     console.error(e);\n     * }\n     * // For a local manifest file:\n     * try {\n     *     const platform = fin.Platform.getCurrentSync();\n     *     platform.launchContentManifest('file:///C:/somefolder/app.json');\n     *     console.log(`content launched successfully into platform`);\n     * } catch(e) {\n     *     console.error(e);\n     * }\n     * ```\n     * @experimental\n     */\n    async launchContentManifest(manifestUrl) {\n        this.wire.sendAction('platform-launch-content-manifest', this.identity).catch(() => {\n            // don't expose\n        });\n        const client = await this.getClient();\n        const manifest = await this.fetchManifest(manifestUrl);\n        client.dispatch('launch-into-platform', { manifest, manifestUrl });\n        return this;\n    }\n    /**\n     * Set the context of a host window. The context will be available to the window itself, and to its child Views. It will be saved in any platform snapshots.\n     * It can be retrieved using {@link Platform#getWindowContext getWindowContext}.\n     * @param context - A field where serializable context data can be stored to be saved in platform snapshots.\n     * @param target - A target window or view may optionally be provided. If no target is provided, the update will be applied\n     * to the current window (if called from a Window) or the current host window (if called from a View).\n     *\n     * @remarks The context data must be serializable.  This can only be called from a window or view that has been launched into a\n     * platform.\n     * This method can be called from the window itself, or from any child view. Context data is shared by all\n     * entities within a window.\n     *\n     * @example\n     * Setting own context:\n     * ```js\n     * const platform = fin.Platform.getCurrentSync();\n     * const contextData = {\n     *     security: 'STOCK',\n     *     currentView: 'detailed'\n     * }\n     *\n     * await platform.setWindowContext(contextData);\n     * // Context of current window is now set to `contextData`\n     * ```\n     *\n     * Setting the context of another window or view:\n     * ```js\n     * const platform = fin.Platform.getCurrentSync();\n     * const contextData = {\n     *     security: 'STOCK',\n     *     currentView: 'detailed'\n     * }\n     *\n     * const windowOrViewIdentity = { uuid: fin.me.uuid, name: 'nameOfWindowOrView' };\n     * await platform.setWindowContext(contextData, windowOrViewIdentity);\n     * // Context of the target window or view is now set to `contextData`\n     * ```\n     *\n     * A view can listen to changes to its host window's context by listening to the `host-context-changed` event.\n     * This event will fire when a host window's context is updated or when the view is reparented to a new window:\n     *\n     * ```js\n     * // From a view\n     * const contextChangeHandler = ({ context }) => {\n     *     console.log('Host window\\'s context has changed. New context data:', context);\n     *     // react to new context data here\n     * }\n     * await fin.me.on('host-context-changed', contextChangeHandler);\n     *\n     * const platform = await fin.Platform.getCurrentSync();\n     * const contextData = {\n     *     security: 'STOCK',\n     *     currentView: 'detailed'\n     * }\n     * platform.setWindowContext(contextData) // contextChangeHandler will log the new context\n     * ```\n     *\n     * To listen to a window's context updates, use the `context-changed` event:\n     * ```js\n     * // From a window\n     * const contextChangeHandler = ({ context }) => {\n     *     console.log('This window\\'s context has changed. New context data:', context);\n     *     // react to new context data here\n     * }\n     * await fin.me.on('context-changed', contextChangeHandler);\n     *\n     * const platform = await fin.Platform.getCurrentSync();\n     * const contextData = {\n     *     security: 'STOCK',\n     *     currentView: 'detailed'\n     * }\n     * platform.setWindowContext(contextData) // contextChangeHandler will log the new context\n     * ```\n     * @experimental\n     */\n    async setWindowContext(context = {}, target) {\n        this.wire.sendAction('platform-set-window-context', this.identity).catch((e) => {\n            // don't expose\n        });\n        if (!context) {\n            throw new Error('Please provide a serializable object or string to set the context.');\n        }\n        const client = await this.getClient();\n        const { entityType } = target ? await this.fin.System.getEntityInfo(target.uuid, target.name) : this.fin.me;\n        await client.dispatch('set-window-context', {\n            context,\n            entityType,\n            target: target || { uuid: this.fin.me.uuid, name: this.fin.me.name }\n        });\n    }\n    /**\n     * Get the context context of a host window that was previously set using {@link Platform#setWindowContext setWindowContext}.\n     * The context will be saved in any platform snapshots.  Returns a promise that resolves to the context.\n     * @param target - A target window or view may optionally be provided. If no target is provided, target will be\n     * the current window (if called from a Window) or the current host window (if called from a View).\n     *\n     * @remarks This method can be called from the window itself, or from any child view. Context data is shared\n     * by all entities within a window.\n     *\n     * @example\n     *\n     * Retrieving context from current window:\n     * ```js\n     * const platform = fin.Platform.getCurrentSync();\n     * const customContext = { answer: 42 };\n     * await platform.setWindowContext(customContext);\n     *\n     * const myContext = await platform.getWindowContext();\n     * console.log(myContext); // { answer: 42 }\n     * ```\n     *\n     * Retrieving the context of another window or view:\n     * ```js\n     * const platform = fin.Platform.getCurrentSync();\n     *\n     * const windowOrViewIdentity = { uuid: fin.me.uuid, name: 'nameOfWindowOrView' };\n     *\n     * const targetWindowContext = await platform.getWindowContext(windowOrViewIdentity);\n     * console.log(targetWindowContext); // context of target window\n     * ```\n     * @experimental\n     */\n    async getWindowContext(target) {\n        this.wire.sendAction('platform-get-window-context', this.identity).catch((e) => {\n            // don't expose\n        });\n        const client = await this.getClient();\n        const { entityType } = target ? await this.fin.System.getEntityInfo(target.uuid, target.name) : this.fin.me;\n        return client.dispatch('get-window-context', {\n            target: target || { uuid: this.fin.me.uuid, name: this.fin.me.name },\n            entityType\n        });\n    }\n    /**\n     * Closes a window. If enableBeforeUnload is enabled in the Platform options, any beforeunload handler set on Views will fire\n     * This behavior can be disabled by setting skipBeforeUnload to false in the options parameter.\n     * @param winId\n     * @param options\n     *\n     * @remarks This method works by setting a `close-requested` handler on the Platform Window. If you have your own `close-requested` handler set on the Platform Window as well,\n     * it is recommended to move that logic over to the [PlatformProvider.closeWindow]{@link PlatformProvider#closeWindow} override to ensure it runs when the Window closes.\n     *\n     * @example\n     *\n     * ```js\n     * // Close the current Window inside a Window context\n     * const platform = await fin.Platform.getCurrent();\n     * platform.closeWindow(fin.me.identity);\n     *\n     * // Close the Window from inside a View context\n     * const platform = await fin.Platform.getCurrent();\n     * const parentWindow = await fin.me.getCurrentWindow();\n     * platform.closeWindow(parentWindow.identity);\n     *\n     * // Close the Window and do not fire the before unload handler on Views\n     * const platform = await fin.Platform.getCurrent();\n     * platform.closeWindow(fin.me.identity, { skipBeforeUnload: true });\n     * ```\n     * @experimental\n     */\n    async closeWindow(windowId, options = { skipBeforeUnload: false }) {\n        this.wire.sendAction('platform-close-window', this.identity).catch((e) => {\n            // don't expose\n        });\n        const client = await this.getClient();\n        return client.dispatch('close-window', { windowId, options });\n    }\n}\nInstance$2.Platform = Platform;\n_Platform_connectToProvider = new WeakMap();\n\nvar layout = {};\n\nvar Factory$2 = {};\n\nvar Instance$1 = {};\n\nvar commonUtils = {};\n\nObject.defineProperty(commonUtils, \"__esModule\", { value: true });\ncommonUtils.overrideFromComposables = commonUtils.isValidPresetType = void 0;\nfunction isValidPresetType(type) {\n    switch (type) {\n        case 'columns':\n        case 'grid':\n        case 'rows':\n        case 'tabs':\n            return true;\n        default:\n            return false;\n    }\n}\ncommonUtils.isValidPresetType = isValidPresetType;\nfunction overrideFromComposables(...overrides) {\n    return (base) => overrides.reduceRight((p, c) => (b) => c(p(b)), (x) => x)(base);\n}\ncommonUtils.overrideFromComposables = overrideFromComposables;\ncommonUtils.default = { isValidPresetType };\n\nvar __classPrivateFieldGet$4 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar _Layout_layoutClient;\nObject.defineProperty(Instance$1, \"__esModule\", { value: true });\nInstance$1.Layout = void 0;\nconst lazy_1 = lazy;\nconst validate_1 = validate;\nconst base_1$5 = base;\nconst common_utils_1 = commonUtils;\nconst layout_entities_1 = layoutEntities;\nconst layout_constants_1$1 = layout_constants;\n/**\n *\n * Layouts give app providers the ability to embed multiple views in a single window. The Layout namespace\n * enables the initialization and manipulation of a window's Layout. A Layout will\n * emit events locally on the DOM element representing the layout-container.\n *\n *\n * ### Layout.DOMEvents\n *\n * When a Layout is created, it emits events onto the DOM element representing the Layout container.\n * This Layout container is the DOM element referenced by containerId in {@link Layout.LayoutModule#init Layout.init}.\n * You can use the built-in event emitter to listen to these events using [addEventListener](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener).\n * The events are emitted synchronously and only in the process where the Layout exists.\n * Any values returned by the called listeners are ignored and will be discarded.\n * If the target DOM element is destroyed, any events that have been set up on that element will be destroyed.\n *\n * @remarks The built-in event emitter is not an OpenFin event emitter so it doesn't share propagation semantics.\n *\n * #### {@link https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener addEventListener(type, listener [, options]);}\n * Adds a listener to the end of the listeners array for the specified event.\n * @example\n * ```js\n * const myLayoutContainer = document.getElementById('layout-container');\n *\n * myLayoutContainer.addEventListener('tab-created', function(event) {\n *      const { tabSelector } = event.detail;\n *      const tabElement = document.getElementById(tabSelector);\n *      const existingColor = tabElement.style.backgroundColor;\n *      tabElement.style.backgroundColor = \"red\";\n *      setTimeout(() => {\n *          tabElement.style.backgroundColor = existingColor;\n *      }, 2000);\n * });\n * ```\n *\n * #### {@link https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/removeEventListener removeEventListener(type, listener [, options]);}\n * Adds a listener to the end of the listeners array for the specified event.\n * @example\n * ```js\n * const myLayoutContainer = document.getElementById('layout-container');\n *\n * const listener = function(event) {\n *     console.log(event.detail);\n *     console.log('container-created event fired once, removing listener');\n *     myLayoutContainer.removeEventListener('container-created', listener);\n * };\n *\n * myLayoutContainer.addEventListener('container-created', listener);\n * ```\n *\n * ### Supported event types are:\n *\n * * tab-created\n * * container-created\n * * layout-state-changed\n * * tab-closed\n * * tab-dropped\n *\n * ### Layout DOM Node Events\n *\n * #### tab-created\n * Generated when a tab is created.  As a user drags and drops tabs within window, new tabs are created.  A single view may have multiple tabs created and destroyed during its lifetime attached to a single window.\n * ```js\n * // The response has the following shape in event.detail:\n * {\n *     containerSelector: \"container-component_A\",\n *     name: \"component_A\",\n *     tabSelector: \"tab-component_A\",\n *     topic: \"openfin-DOM-event\",\n *     type: \"tab-created\",\n *     uuid: \"OpenFin POC\"\n * }\n * ```\n *\n * #### container-created\n * Generated when a container is created.  A single view will have only one container during its lifetime attached to a single window and the container's lifecycle is tied to the view.  To discover when the container is destroyed, please listen to view-detached event.\n * ```js\n * // The response has the following shape in event.detail:\n * {\n *     containerSelector: \"container-component_A\",\n *     name: \"component_A\",\n *     tabSelector: \"tab-component_A\",\n *     topic: \"openfin-DOM-event\",\n *     type: \"container-created\",\n *     uuid: \"OpenFin POC\"\n * }\n * ```\n *\n * ### layout-state-changed\n * Generated when the state of the layout changes in any way, such as a view added/removed/replaced. Note that this event can fire frequently as the underlying layout can change multiple components from all kinds of changes (resizing for example). Given this, it is recommended to debounce this event and then you can use the {@link Layout#getConfig Layout.getConfig} API to retrieve the most up-to-date state.\n * ```js\n * // The response has the following shape in event.detail\n * {\n *     containerSelector: \"container-component_A\",\n *     name: \"component_A\",\n *     tabSelector: \"tab-component_A\",\n *     topic: \"openfin-DOM-event\",\n *     type: \"layout-state-changed\",\n *     uuid: \"OpenFin POC\"\n * }\n * ```\n *\n * #### tab-closed\n * Generated when a tab is closed.\n * ```js\n * // The response has the following shape in event.detail:\n * {\n *     containerSelector: \"container-component_A\",\n *     name: \"component_A\",\n *     tabSelector: \"tab-component_A\",\n *     topic: \"openfin-DOM-event\",\n *     type: \"tab-closed\",\n *     uuid: \"OpenFin POC\",\n *     url: \"http://openfin.co\"   // The url of the view that was closed.\n * }\n * ```\n *\n * #### tab-dropped\n * Generated when a tab is dropped.\n * ```js\n * // The response has the following shape in event.detail:\n * {\n *     containerSelector: \"container-component_A\",\n *     name: \"component_A\",\n *     tabSelector: \"tab-component_A\",\n *     topic: \"openfin-DOM-event\",\n *     type: \"tab-dropped\",\n *     uuid: \"OpenFin POC\",\n *     url: \"http://openfin.co\"    // The url of the view linked to the dropped tab.\n * }\n * ```\n */\nclass Layout extends base_1$5.Base {\n    /**\n     * @internal\n     */\n    // eslint-disable-next-line no-shadow\n    constructor(identity, wire) {\n        super(wire);\n        /**\n         * @internal\n         * Lazily constructed {@link LayoutEntitiesClient} bound to this platform's client and identity\n         * The client is for {@link LayoutEntitiesController}\n         */\n        _Layout_layoutClient.set(this, new lazy_1.Lazy(async () => layout_entities_1.LayoutNode.newLayoutEntitiesClient(await this.platform.getClient(), layout_constants_1$1.LAYOUT_CONTROLLER_ID, this.identity)));\n        /**\n         * Replaces a Platform window's layout with a new layout.\n         *\n         * @remarks Any views that were in the old layout but not the new layout will be destroyed. Views will be assigned a randomly generated name to avoid collisions.\n         * @example\n         * ```js\n         * let windowIdentity;\n         * if (fin.me.isWindow) {\n         *     windowIdentity = fin.me.identity;\n         * } else if (fin.me.isView) {\n         *     windowIdentity = (await fin.me.getCurrentWindow()).identity;\n         * } else {\n         *     throw new Error('Not running in a platform View or Window');\n         * }\n         *\n         * const layout = fin.Platform.Layout.wrapSync(windowIdentity);\n         *\n         * const newLayout = {\n         *     content: [\n         *         {\n         *             type: 'stack',\n         *             content: [\n         *                 {\n         *                     type: 'component',\n         *                     componentName: 'view',\n         *                     componentState: {\n         *                         name: 'new_component_A1',\n         *                         processAffinity: 'ps_1',\n         *                         url: 'https://www.example.com'\n         *                     }\n         *                 },\n         *                 {\n         *                     type: 'component',\n         *                     componentName: 'view',\n         *                     componentState: {\n         *                         name: 'new_component_A2',\n         *                         url: 'https://cdn.openfin.co/embed-web/chart.html'\n         *                     }\n         *                 }\n         *             ]\n         *         }\n         *     ]\n         * };\n         *\n         * layout.replace(newLayout);\n         * ```\n         */\n        this.replace = async (layout) => {\n            this.wire.sendAction('layout-replace').catch((e) => {\n                // don't expose\n            });\n            const client = await this.platform.getClient();\n            await client.dispatch('replace-layout', {\n                target: this.identity,\n                opts: { layout }\n            });\n        };\n        /**\n         * Replaces the specified view with a view with the provided configuration.\n         *\n         * @remarks The old view is stripped of its listeners and either closed or attached to the provider window\n         * depending on `detachOnClose` view option.\n         *\n         * @param viewToReplace Identity of the view to be replaced\n         * @param newView Creation options of the new view.\n         *\n         * @example\n         * ```js\n         * let currentWindow;\n         * if (fin.me.isWindow) {\n         *     currentWindow = fin.me;\n         * } else if (fin.me.isView) {\n         *     currentWindow = await fin.me.getCurrentWindow();\n         * } else {\n         *     throw new Error('Not running in a platform View or Window');\n         * }\n         *\n         * const layout = fin.Platform.Layout.wrapSync(currentWindow.identity);\n         * const viewToReplace = (await currentWindow.getCurrentViews())[0];\n         * const newViewConfig = {url: 'https://example.com'};\n         * await layout.replaceView(viewToReplace.identity, newViewConfig);\n         * ```\n         */\n        this.replaceView = async (viewToReplace, newView) => {\n            this.wire.sendAction('layout-replace-view').catch((e) => {\n                // don't expose\n            });\n            const client = await this.platform.getClient();\n            await client.dispatch('replace-view', {\n                target: this.identity,\n                opts: { viewToReplace, newView }\n            });\n        };\n        /**\n         * Replaces a Platform window's layout with a preset layout arrangement using the existing Views attached to the window.\n         * The preset options are `columns`, `grid`, `rows`, and `tabs`.\n         * @param options Mandatory object with `presetType` property that sets which preset layout arrangement to use.\n         * The preset options are `columns`, `grid`, `rows`, and `tabs`.\n         *\n         * @example\n         * ```js\n         * let windowIdentity;\n         * if (fin.me.isWindow) {\n         *     windowIdentity = fin.me.identity;\n         * } else if (fin.me.isView) {\n         *     windowIdentity = (await fin.me.getCurrentWindow()).identity;\n         * } else {\n         *     throw new Error('Not running in a platform View or Window');\n         * }\n         *\n         * const layout = fin.Platform.Layout.wrapSync(windowIdentity);\n         * await layout.applyPreset({ presetType: 'grid' });\n         *\n         * // wait 5 seconds until you change the layout from grid to tabs\n         * await new Promise (res => setTimeout(res, 5000));\n         * await layout.applyPreset({ presetType: 'tabs' });\n         * ```\n         */\n        this.applyPreset = async (options) => {\n            this.wire.sendAction('layout-apply-preset').catch((e) => {\n                // don't expose\n            });\n            const client = await this.platform.getClient();\n            const { presetType } = options;\n            if (!presetType || !(0, common_utils_1.isValidPresetType)(presetType)) {\n                throw new Error('Cannot apply preset layout, please include an applicable presetType property in the PresetLayoutOptions.');\n            }\n            await client.dispatch('apply-preset-layout', {\n                target: this.identity,\n                opts: { presetType }\n            });\n        };\n        const errorMsg = (0, validate_1.validateIdentity)(identity);\n        if (errorMsg) {\n            throw new Error(errorMsg);\n        }\n        this.identity = identity;\n        this.platform = this.fin.Platform.wrapSync({ uuid: identity.uuid });\n        if (identity.uuid === this.fin.me.uuid && identity.name === this.fin.me.name) {\n            this.init = this.fin.Platform.Layout.init;\n        }\n    }\n    /**\n     * Returns the configuration of the window's layout.  Returns the same information that is returned for all windows in getSnapshot.\n     *\n     * @remarks Cannot be called from a View.\n     *\n     *\n     * @example\n     * ```js\n     * const layout = fin.Platform.Layout.getCurrentSync();\n     * // Use wrapped instance to get the layout configuration of the current window's Layout:\n     * const layoutConfig = await layout.getConfig();\n     * ```\n     */\n    async getConfig() {\n        this.wire.sendAction('layout-get-config').catch((e) => {\n            // don't expose\n        });\n        const client = await this.platform.getClient();\n        return client.dispatch('get-frame-snapshot', {\n            target: this.identity\n        });\n    }\n    /**\n     * Retrieves the attached views in current window layout.\n     *\n     * @example\n     * ```js\n     * const layout = fin.Platform.Layout.getCurrentSync();\n     * const views = await layout.getCurrentViews();\n     * ```\n     */\n    async getCurrentViews() {\n        this.wire.sendAction('layout-get-views').catch((e) => {\n            // don't expose\n        });\n        const client = await this.platform.getClient();\n        const viewIdentities = await client.dispatch('get-layout-views', {\n            target: this.identity\n        });\n        return viewIdentities.map((identity) => this.fin.View.wrapSync(identity));\n    }\n    /**\n     * Retrieves the top level content item of the layout.\n     *\n     * @remarks Cannot be called from a view.\n     *\n     *\n     *\n     * @example\n     * ```js\n     * if (!fin.me.isWindow) {\n     *     throw new Error('Not running in a platform View.');\n     * }\n     *\n     * // From the layout window\n     * const layout = fin.Platform.Layout.getCurrentSync();\n     * // Retrieves the ColumnOrRow instance\n     * const rootItem = await layout.getRootItem();\n     * const content = await rootItem.getContent();\n     * console.log(`The root ColumnOrRow instance has ${content.length} item(s)`);\n     * ```\n     */\n    async getRootItem() {\n        this.wire.sendAction('layout-get-root-item').catch(() => {\n            // don't expose\n        });\n        const client = await __classPrivateFieldGet$4(this, _Layout_layoutClient, \"f\").getValue();\n        const root = await client.getRoot('layoutName' in this.identity ? this.identity : undefined);\n        return layout_entities_1.LayoutNode.getEntity(root, client);\n    }\n}\nInstance$1.Layout = Layout;\n_Layout_layoutClient = new WeakMap();\n\nvar __classPrivateFieldGet$3 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar __classPrivateFieldSet$3 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar _LayoutModule_instances, _LayoutModule_layoutInitializationAttempted, _LayoutModule_layoutManager, _LayoutModule_getLayoutManagerSpy, _LayoutModule_getSafeLayoutManager;\nObject.defineProperty(Factory$2, \"__esModule\", { value: true });\nFactory$2.LayoutModule = void 0;\nconst base_1$4 = base;\nconst Instance_1$2 = Instance$1;\nconst layout_constants_1 = layout_constants;\n/**\n * Static namespace for OpenFin API methods that interact with the {@link Layout} class, available under `fin.Platform.Layout`.\n */\nclass LayoutModule extends base_1$4.Base {\n    constructor() {\n        super(...arguments);\n        _LayoutModule_instances.add(this);\n        _LayoutModule_layoutInitializationAttempted.set(this, false);\n        _LayoutModule_layoutManager.set(this, null);\n        /**\n         * Initialize the window's Layout.\n         *\n         * @remarks Must be called from a custom window that has a 'layout' option set upon creation of that window.\n         * If a containerId is not provided, this method attempts to find an element with the id `layout-container`.\n         * A Layout will emit events locally on the DOM element representing the layout-container.\n         * In order to capture the relevant events during Layout initiation, set up the listeners on the DOM element prior to calling `init`.\n         * @param options - Layout init options.\n         *\n         * @experimental\n         *\n         * @example\n         * ```js\n         * // If no options are included, the layout in the window options is initialized in an element with the id `layout-container`\n         * const layout = await fin.Platform.Layout.init();\n         * ```\n         * <br>\n         *\n         * ```js\n         * const containerId = 'my-custom-container-id';\n         *\n         * const myLayoutContainer = document.getElementById(containerId);\n         *\n         * myLayoutContainer.addEventListener('tab-created', function(event) {\n         *     const { tabSelector } = event.detail;\n         *     const tabElement = document.getElementById(tabSelector);\n         *     const existingColor = tabElement.style.backgroundColor;\n         *     tabElement.style.backgroundColor = \"red\";\n         *     setTimeout(() => {\n         *         tabElement.style.backgroundColor = existingColor;\n         *     }, 2000);\n         * });\n         *\n         * // initialize the layout into an existing HTML element with the div `my-custom-container-id`\n         * // the window must have been created with a layout in its window options\n         * const layout = await fin.Platform.Layout.init({ containerId });\n         * ```\n         */\n        this.init = async (options = {}) => {\n            this.wire.sendAction('layout-init').catch((e) => {\n                // don't expose\n            });\n            if (!this.wire.environment.layoutAllowedInContext(this.fin)) {\n                throw new Error('Layout.init can only be called from a Window context.');\n            }\n            if (__classPrivateFieldGet$3(this, _LayoutModule_layoutInitializationAttempted, \"f\")) {\n                throw new Error('Layout.init was already called, please use Layout.create to add additional layouts.');\n            }\n            if (this.wire.environment.type === 'openfin') {\n                // preload the client\n                await this.fin.Platform.getCurrentSync().getClient();\n            }\n            __classPrivateFieldSet$3(this, _LayoutModule_layoutInitializationAttempted, true, \"f\");\n            // TODO: rename to createLayoutManager\n            __classPrivateFieldSet$3(this, _LayoutModule_layoutManager, await this.wire.environment.initLayoutManager(this.fin, this.wire, options), \"f\");\n            await this.wire.environment.applyLayoutSnapshot(this.fin, __classPrivateFieldGet$3(this, _LayoutModule_layoutManager, \"f\"), options);\n            const meIdentity = { name: this.fin.me.name, uuid: this.fin.me.uuid };\n            if (!options.layoutManagerOverride) {\n                // CORE-1081 to be removed when we actually delete the `layoutManager` prop\n                // in single-layout case, we return the undocumented layoutManager type\n                const layoutIdentity = { layoutName: layout_constants_1.DEFAULT_LAYOUT_KEY, ...meIdentity };\n                return __classPrivateFieldGet$3(this, _LayoutModule_getLayoutManagerSpy, \"f\").call(this, layoutIdentity);\n            }\n            return this.wrapSync(meIdentity);\n        };\n        _LayoutModule_getLayoutManagerSpy.set(this, (layoutIdentity) => {\n            const msg = '[Layout] You are using a deprecated property `layoutManager` - it will throw if you access it starting in v37.';\n            const managerProxy = new Proxy({}, {\n                get(target, key) {\n                    console.warn(`[Layout-mgr-proxy] accessing ${key.toString()}`);\n                    throw new Error(msg);\n                }\n            });\n            const layout = Object.assign(this.wrapSync(layoutIdentity), { layoutManager: managerProxy });\n            const layoutProxy = new Proxy(layout, {\n                get(target, key) {\n                    if (key === 'layoutManager') {\n                        console.warn(`[Layout-proxy] accessing ${key.toString()}`);\n                        throw new Error(msg);\n                    }\n                    return target[key];\n                }\n            });\n            return layoutProxy;\n        });\n        /**\n         * Returns the layout manager for the current window\n         * @returns\n         */\n        this.getCurrentLayoutManagerSync = () => {\n            return __classPrivateFieldGet$3(this, _LayoutModule_instances, \"m\", _LayoutModule_getSafeLayoutManager).call(this, `fin.Platform.Layout.getCurrentLayoutManagerSync()`);\n        };\n        this.create = async (options) => {\n            return this.wire.environment.createLayout(__classPrivateFieldGet$3(this, _LayoutModule_instances, \"m\", _LayoutModule_getSafeLayoutManager).call(this, `fin.Platform.Layout.create()`), options);\n        };\n        this.destroy = async (layoutIdentity) => {\n            return this.wire.environment.destroyLayout(__classPrivateFieldGet$3(this, _LayoutModule_instances, \"m\", _LayoutModule_getSafeLayoutManager).call(this, `fin.Platform.Layout.destroy()`), layoutIdentity);\n        };\n    }\n    /**\n     * Asynchronously returns a Layout object that represents a Window's layout.\n     *\n     * @example\n     * ```js\n     * let windowIdentity;\n     * if (!fin.me.isWindow) {\n     *     windowIdentity = fin.me.identity;\n     * } else if (fin.me.isView) {\n     *     windowIdentity = (await fin.me.getCurrentWindow()).identity;\n     * } else {\n     *     throw new Error('Not running in a platform View or Window');\n     * }\n     *\n     * const layout = await fin.Platform.Layout.wrap(windowIdentity);\n     * // Use wrapped instance to control layout, e.g.:\n     * const layoutConfig = await layout.getConfig();\n     * ```\n     */\n    async wrap(identity) {\n        this.wire.sendAction('layout-wrap').catch((e) => {\n            // don't expose\n        });\n        return new Instance_1$2.Layout(identity, this.wire);\n    }\n    /**\n     * Synchronously returns a Layout object that represents a Window's layout.\n     *\n     * @example\n     * ```js\n     * let windowIdentity;\n     * if (!fin.me.isWindow) {\n     *     windowIdentity = fin.me.identity;\n     * } else if (fin.me.isView) {\n     *     windowIdentity = (await fin.me.getCurrentWindow()).identity;\n     * } else {\n     *     throw new Error('Not running in a platform View or Window');\n     * }\n     *\n     * const layout = fin.Platform.Layout.wrapSync(windowIdentity);\n     * // Use wrapped instance to control layout, e.g.:\n     * const layoutConfig = await layout.getConfig();\n     * ```\n     */\n    wrapSync(identity) {\n        this.wire.sendAction('layout-wrap-sync').catch((e) => {\n            // don't expose\n        });\n        return new Instance_1$2.Layout(identity, this.wire);\n    }\n    /**\n     * Asynchronously returns a Layout object that represents a Window's layout.\n     *\n     * @example\n     * ```js\n     * const layout = await fin.Platform.Layout.getCurrent();\n     * // Use wrapped instance to control layout, e.g.:\n     * const layoutConfig = await layout.getConfig();\n     * ```\n     */\n    async getCurrent() {\n        this.wire.sendAction('layout-get-current').catch((e) => {\n            // don't expose\n        });\n        if (!this.fin.me.isWindow) {\n            throw new Error('You are not in a Window context.  Only Windows can have a Layout.');\n        }\n        const { uuid, name } = this.fin.me;\n        return this.wrap({ uuid, name });\n    }\n    /**\n     * Synchronously returns a Layout object that represents a Window's layout.\n     *\n     * @remarks Cannot be called from a view.\n     *\n     *\n     * @example\n     * ```js\n     * const layout = fin.Platform.Layout.getCurrentSync();\n     * // Use wrapped instance to control layout, e.g.:\n     * const layoutConfig = await layout.getConfig();\n     * ```\n     */\n    getCurrentSync() {\n        this.wire.sendAction('layout-get-current-sync').catch((e) => {\n            // don't expose\n        });\n        if (!this.fin.me.isWindow) {\n            throw new Error('You are not in a Window context.  Only Windows can have a Layout.');\n        }\n        const { uuid, name } = this.fin.me;\n        return this.wrapSync({ uuid, name });\n    }\n}\nFactory$2.LayoutModule = LayoutModule;\n_LayoutModule_layoutInitializationAttempted = new WeakMap(), _LayoutModule_layoutManager = new WeakMap(), _LayoutModule_getLayoutManagerSpy = new WeakMap(), _LayoutModule_instances = new WeakSet(), _LayoutModule_getSafeLayoutManager = function _LayoutModule_getSafeLayoutManager(method) {\n    if (!__classPrivateFieldGet$3(this, _LayoutModule_layoutManager, \"f\")) {\n        throw new Error(`You must call init before using the API ${method}`);\n    }\n    return __classPrivateFieldGet$3(this, _LayoutModule_layoutManager, \"f\");\n};\n\n(function (exports) {\n\t/**\n\t * Entry point for the OpenFin `Layout` subset of the `Platform` API (`fin.Platform.Layout`).\n\t *\n\t * * {@link LayoutModule} contains static members of the `Layout` API, accessible through `fin.Platform.Layout`.\n\t * * {@link Layout} describes an instance of an OpenFin Layout, e.g. as returned by `fin.Platform.Layout.getCurrent`.\n\t *\n\t * These are separate code entities, and are documented separately. In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/32.114.76.10/index.html),\n\t * both of these were documented on the same page.\n\t *\n\t * @packageDocumentation\n\t *\n\t */\n\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t    }\n\t    Object.defineProperty(o, k2, desc);\n\t}) : (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    o[k2] = m[k];\n\t}));\n\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t};\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t__exportStar(Factory$2, exports);\n\t__exportStar(Instance$1, exports); \n} (layout));\n\nObject.defineProperty(Factory$3, \"__esModule\", { value: true });\nFactory$3.PlatformModule = void 0;\nconst base_1$3 = base;\nconst Instance_1$1 = Instance$2;\nconst index_1$1 = layout;\n/**\n * Static namespace for OpenFin API methods that interact with the {@link Platform} class, available under `fin.Platform`.\n */\nclass PlatformModule extends base_1$3.Base {\n    /**\n     * @internal\n     */\n    constructor(wire, channel) {\n        super(wire);\n        this._channel = channel;\n        /**\n         *\n         * @desc Layouts give app providers the ability to embed multiple views in a single window.  The Layout namespace\n         * enables the initialization and manipulation of a window's Layout.  A Layout will\n         * <a href=\"tutorial-Layout.DOMEvents.html\">emit events locally</a> on the DOM element representing the layout-container.\n         */\n        this.Layout = new index_1$1.LayoutModule(this.wire);\n    }\n    /**\n     * Initializes a Platform. Must be called from the Provider when using a custom provider.\n     * @param options - platform options including a callback function that can be used to extend or replace\n     * default Provider behavior.\n     *\n     * @remarks Must be called from the Provider when using a custom provider.\n     *\n     * @example\n     *\n     * ```js\n     * // From Provider context\n     * await fin.Platform.init();\n     * // Platform API is now hooked up and windows contained in the manifest snapshot are open.\n     * ```\n     *\n     * `Platform.init` accepts an options object that can contain a callback function which can be used to extend or\n     * replace default Provider behavior. As an argument, this function will receive the `Provider` class, which is\n     * used to handle Platform actions. The function must return an object with methods to handle Platform API actions.\n     * The recommended approach is to extend the `Provider` class, overriding the methods you wish to alter, and return an\n     * instance of your subclass:\n     *\n     * ```js\n     * const overrideCallback = async (PlatformProvider) => {\n     *     // Actions can be performed before initialization.\n     *     // e.g. we might authenticate a user, set up a Channel, etc before initializing the Platform.\n     *     const { manifestUrl } = await fin.Application.getCurrentSync().getInfo();\n     *\n     *     // Extend or replace default PlatformProvider behavior by extending the PlatformProvider class.\n     *     class MyOverride extends PlatformProvider {\n     *         // Default behavior can be changed by implementing methods with the same names as those used by the default PlatformProvider.\n     *         async getSnapshot() {\n     *             // Since we are extending the class, we can call `super` methods to access default behavior.\n     *             const snapshot = await super.getSnapshot();\n     *             // But we can modify return values.\n     *             return { ...snapshot, answer: 42, manifestUrl };\n     *         }\n     *         async replaceLayout({ opts, target }) {\n     *             // To disable an API method, overwrite with a noop function.\n     *             return;\n     *         }\n     *     }\n     *     // Return instance with methods to be consumed by Platform.\n     *     // The returned object must implement all methods of the PlatformProvider class.\n     *     // By extending the class, we can simply inherit methods we do not wish to alter.\n     *     return new MyOverride();\n     * };\n     *\n     * fin.Platform.init({overrideCallback});\n     * ```\n     * @experimental\n     */\n    async init(options) {\n        if (!fin.__internal_.isPlatform || fin.me.name !== fin.me.uuid) {\n            throw new Error('fin.Platform.init should only be called from a custom platform provider running in the main window of the application.');\n        }\n        return this.wire.environment.initPlatform(this.fin, options);\n    }\n    /**\n     * Asynchronously returns a Platform object that represents an existing platform.\n     *\n     * @example\n     * ```js\n     * const { identity } = fin.me;\n     * const platform = await fin.Platform.wrap(identity);\n     * // Use wrapped instance to control layout, e.g.:\n     * const snapshot = await platform.getSnapshot();\n     * ```\n     */\n    async wrap(identity) {\n        this.wire.sendAction('platform-wrap').catch((e) => {\n            // don't expose\n        });\n        return new Instance_1$1.Platform({ uuid: identity.uuid }, this._channel);\n    }\n    /**\n     * Synchronously returns a Platform object that represents an existing platform.\n     *\n     * @example\n     * ```js\n     * const { identity } = fin.me;\n     * const platform = fin.Platform.wrapSync(identity);\n     * // Use wrapped instance to control layout, e.g.:\n     * const snapshot = await platform.getSnapshot();\n     * ```\n     */\n    wrapSync(identity) {\n        this.wire.sendAction('platform-wrap-sync').catch((e) => {\n            // don't expose\n        });\n        return new Instance_1$1.Platform({ uuid: identity.uuid }, this._channel);\n    }\n    /**\n     * Asynchronously returns a Platform object that represents the current platform.\n     *\n     * @example\n     * ```js\n     * const platform = await fin.Platform.getCurrent();\n     * // Use wrapped instance to control layout, e.g.:\n     * const snapshot = await platform.getSnapshot();\n     * ```\n     */\n    async getCurrent() {\n        this.wire.sendAction('platform-get-current').catch((e) => {\n            // don't expose\n        });\n        return this.wrap({ uuid: this.wire.me.uuid });\n    }\n    /**\n     * Synchronously returns a Platform object that represents the current platform.\n     *\n     * @example\n     * ```js\n     * const platform = fin.Platform.getCurrentSync();\n     * // Use wrapped instance to control layout, e.g.:\n     * const snapshot = await platform.getSnapshot();\n     * ```\n     */\n    getCurrentSync() {\n        this.wire.sendAction('platform-get-current-sync').catch((e) => {\n            // don't expose\n        });\n        return this.wrapSync({ uuid: this.wire.me.uuid });\n    }\n    /**\n     * Creates and starts a Platform and returns a wrapped and running Platform instance. The wrapped Platform methods can\n     * be used to launch content into the platform.  Promise will reject if the platform is already running.\n     *\n     * @example\n     * ```js\n     * try {\n     *     const platform = await fin.Platform.start({\n     *         uuid: 'platform-1',\n     *         autoShow: false,\n     *         defaultWindowOptions: {\n     *             stylesheetUrl: 'css-sheet-url',\n     *             cornerRounding: {\n     *                 height: 10,\n     *                 width: 10\n     *             }\n     *         }\n     *     });\n     *     console.log('Platform is running', platform);\n     * } catch(e) {\n     *     console.error(e);\n     * }\n     * ```\n     */\n    start(platformOptions) {\n        this.wire.sendAction('platform-start').catch((e) => {\n            // don't expose\n        });\n        // eslint-disable-next-line no-async-promise-executor\n        return new Promise(async (resolve, reject) => {\n            try {\n                const { uuid } = platformOptions;\n                // @ts-expect-error using private variable.\n                const app = await this.fin.Application._create({ ...platformOptions, isPlatformController: true });\n                // TODO: fix typing (internal)\n                // @ts-expect-error\n                app.once('platform-api-ready', () => resolve(this.wrapSync({ uuid })));\n                // @ts-expect-error using private variable.\n                app._run({ uuid });\n            }\n            catch (e) {\n                reject(e);\n            }\n        });\n    }\n    /**\n     * Retrieves platforms's manifest and returns a wrapped and running Platform.  If there is a snapshot in the manifest,\n     * it will be launched into the platform.\n     * @param manifestUrl - The URL of platform's manifest.\n     * @param opts - Parameters that the RVM will use.\n     *\n     * @example\n     * ```js\n     * try {\n     *     const platform = await fin.Platform.startFromManifest('https://openfin.github.io/golden-prototype/public.json');\n     *     console.log('Platform is running, wrapped platform: ', platform);\n     * } catch(e) {\n     *     console.error(e);\n     * }\n     * // For a local manifest file:\n     * try {\n     *     const platform = await fin.Platform.startFromManifest('file:///C:/somefolder/app.json');\n     *     console.log('Platform is running, wrapped platform: ', platform);\n     * } catch(e) {\n     *     console.error(e);\n     * }\n     * ```\n     */\n    startFromManifest(manifestUrl, opts) {\n        this.wire.sendAction('platform-start-from-manifest').catch((e) => {\n            // don't expose\n        });\n        // eslint-disable-next-line no-async-promise-executor\n        return new Promise(async (resolve, reject) => {\n            try {\n                // @ts-expect-error using private variable.\n                const app = await this.fin.Application._createFromManifest(manifestUrl);\n                // TODO: fix typing (internal)\n                // @ts-expect-error\n                app.once('platform-api-ready', () => resolve(this.wrapSync({ uuid: app.identity.uuid })));\n                // @ts-expect-error using private method without warning.\n                app._run(opts);\n            }\n            catch (e) {\n                reject(e);\n            }\n        });\n    }\n}\nFactory$3.PlatformModule = PlatformModule;\n\n(function (exports) {\n\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t    }\n\t    Object.defineProperty(o, k2, desc);\n\t}) : (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    o[k2] = m[k];\n\t}));\n\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t};\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t/**\n\t * Entry points for the OpenFin `Platform` API (`fin.Platform`)\n\t *\n\t * * {@link PlatformModule} contains static members of the `Platform` API, accessible through `fin.Platform`.\n\t * * {@link Platform} describes an instance of an OpenFin Platform, e.g. as returned by `fin.Platform.getCurrent`.\n\t *\n\t * These are separate code entities, and are documented separately.  In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/32.114.76.10/index.html),\n\t * both of these were documented on the same page.\n\t *\n\t * @packageDocumentation\n\t */\n\t__exportStar(Factory$3, exports);\n\t__exportStar(Instance$2, exports); \n} (platform));\n\nvar me = {};\n\n(function (exports) {\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\texports.getMe = exports.getBaseMe = exports.environmentUnsupportedMessage = void 0;\n\tconst view_1 = requireView();\n\tconst frame_1 = frame;\n\tconst window_1 = requireWindow();\n\tconst external_application_1 = externalApplication;\n\texports.environmentUnsupportedMessage = 'You are not running in OpenFin.';\n\tfunction getBaseMe(entityType, uuid, name) {\n\t    const entityTypeHelpers = {\n\t        isView: entityType === 'view',\n\t        isWindow: entityType === 'window',\n\t        isFrame: entityType === 'iframe',\n\t        isExternal: entityType === 'external connection'\n\t    };\n\t    return { ...entityTypeHelpers, uuid, name, entityType };\n\t}\n\texports.getBaseMe = getBaseMe;\n\t// We need to do a lot of casting as unknown here because the compiler get's confused about matching types. What matters is that it works on the outside\n\tfunction getMe(wire) {\n\t    const { uuid, name, entityType } = wire.me;\n\t    const unsupportedInterop = {\n\t        setContext() {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        addContextHandler() {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        getContextGroups() {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        joinContextGroup() {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        removeFromContextGroup() {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        getAllClientsInContextGroup() {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        getInfoForContextGroup() {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        }\n\t    };\n\t    const fallbackErrorMessage = 'Interop API has not been instantiated. Either connection has failed or you have not declared interop in your config.';\n\t    const fallbackInterop = {\n\t        setContext() {\n\t            throw new Error(fallbackErrorMessage);\n\t        },\n\t        addContextHandler() {\n\t            throw new Error(fallbackErrorMessage);\n\t        },\n\t        getContextGroups() {\n\t            throw new Error(fallbackErrorMessage);\n\t        },\n\t        joinContextGroup() {\n\t            throw new Error(fallbackErrorMessage);\n\t        },\n\t        removeFromContextGroup() {\n\t            throw new Error(fallbackErrorMessage);\n\t        },\n\t        getAllClientsInContextGroup() {\n\t            throw new Error(fallbackErrorMessage);\n\t        },\n\t        getInfoForContextGroup() {\n\t            throw new Error(fallbackErrorMessage);\n\t        }\n\t    };\n\t    const unsupportedEventBase = {\n\t        eventNames: () => {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        emit: () => {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        listeners: () => {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        listenerCount: () => {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        on: () => {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        addListener: () => {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        once: () => {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        prependListener: () => {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        prependOnceListener: () => {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        removeListener: () => {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        removeAllListeners: () => {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        }\n\t    };\n\t    switch (entityType) {\n\t        case 'view':\n\t            return Object.assign(new view_1.View(wire, { uuid, name }), getBaseMe(entityType, uuid, name), {\n\t                interop: fallbackInterop,\n\t                isOpenFin: true\n\t            });\n\t        case 'window':\n\t            return Object.assign(new window_1._Window(wire, { uuid, name }), getBaseMe(entityType, uuid, name), {\n\t                interop: fallbackInterop,\n\t                isOpenFin: true\n\t            });\n\t        case 'iframe':\n\t            return Object.assign(new frame_1._Frame(wire, { uuid, name }), getBaseMe(entityType, uuid, name), {\n\t                interop: fallbackInterop,\n\t                isOpenFin: true\n\t            });\n\t        case 'external connection':\n\t            return Object.assign(new external_application_1.ExternalApplication(wire, { uuid }), getBaseMe(entityType, uuid, name), {\n\t                interop: fallbackInterop,\n\t                isOpenFin: false\n\t            });\n\t        default:\n\t            return {\n\t                ...getBaseMe(entityType, uuid, name),\n\t                ...unsupportedEventBase,\n\t                interop: unsupportedInterop,\n\t                isOpenFin: false\n\t            };\n\t    }\n\t}\n\texports.getMe = getMe; \n} (me));\n\nvar interop = {};\n\nvar Factory$1 = {};\n\nvar inaccessibleObject = {};\n\nObject.defineProperty(inaccessibleObject, \"__esModule\", { value: true });\ninaccessibleObject.createWarningObject = inaccessibleObject.createUnusableObject = void 0;\nfunction createUnusableObject(message) {\n    const handle = () => {\n        throw new Error(message);\n    };\n    return new Proxy({}, {\n        apply: handle,\n        construct: handle,\n        defineProperty: handle,\n        deleteProperty: handle,\n        get: handle,\n        getOwnPropertyDescriptor: handle,\n        getPrototypeOf: handle,\n        has: handle,\n        isExtensible: handle,\n        ownKeys: handle,\n        preventExtensions: handle,\n        set: handle,\n        setPrototypeOf: handle\n    });\n}\ninaccessibleObject.createUnusableObject = createUnusableObject;\nfunction createWarningObject(message, obj) {\n    return new Proxy(obj, {\n        get: (...args) => {\n            // eslint-disable-next-line no-console\n            console.warn(message);\n            return Reflect.get(...args);\n        },\n        set: (...args) => {\n            // eslint-disable-next-line no-console\n            console.warn(message);\n            return Reflect.set(...args);\n        },\n        getOwnPropertyDescriptor: (...args) => {\n            // eslint-disable-next-line no-console\n            console.warn(message);\n            return Reflect.getOwnPropertyDescriptor(...args);\n        },\n        ownKeys: (...args) => {\n            // eslint-disable-next-line no-console\n            console.warn(message);\n            return Reflect.ownKeys(...args);\n        }\n    });\n}\ninaccessibleObject.createWarningObject = createWarningObject;\n\nvar InteropBroker = {};\n\nvar SessionContextGroupBroker = {};\n\nvar hasRequiredSessionContextGroupBroker;\n\nfunction requireSessionContextGroupBroker () {\n\tif (hasRequiredSessionContextGroupBroker) return SessionContextGroupBroker;\n\thasRequiredSessionContextGroupBroker = 1;\n\tObject.defineProperty(SessionContextGroupBroker, \"__esModule\", { value: true });\n\tconst _1 = requireInterop();\n\tlet SessionContextGroupBroker$1 = class SessionContextGroupBroker {\n\t    constructor(provider, id) {\n\t        this.provider = provider;\n\t        this.id = id;\n\t        this.lastContext = undefined;\n\t        this.contextGroupMap = new Map();\n\t        this.clients = new Map();\n\t        this.registerListeners();\n\t    }\n\t    registerListeners() {\n\t        this.provider.register(`sessionContextGroup:getContext-${this.id}`, this.getCurrentContext.bind(this));\n\t        this.provider.register(`sessionContextGroup:setContext-${this.id}`, this.setContext.bind(this));\n\t        this.provider.register(`sessionContextGroup:handlerAdded-${this.id}`, this.handlerAdded.bind(this));\n\t        this.provider.register(`sessionContextGroup:handlerRemoved-${this.id}`, this.handlerRemoved.bind(this));\n\t    }\n\t    getCurrentContext(payload) {\n\t        return payload.type ? this.contextGroupMap.get(payload.type) : this.lastContext;\n\t    }\n\t    setContext(payload, clientIdentity) {\n\t        const { context } = payload;\n\t        const contextIntegrityCheckResult = _1.InteropBroker.checkContextIntegrity(context);\n\t        if (contextIntegrityCheckResult.isValid === false) {\n\t            throw new Error(`Failed to set Context - bad Context. Reason: ${contextIntegrityCheckResult.reason}. Context: ${JSON.stringify(context)}`);\n\t        }\n\t        const clientState = this.getClientState(clientIdentity);\n\t        if (!clientState) {\n\t            // This shouldn't get hit.\n\t            throw new Error(`Client with Identity: ${clientIdentity.uuid} ${clientIdentity.name} not in Session Client State Map`);\n\t        }\n\t        // set the context\n\t        this.contextGroupMap.set(context.type, context);\n\t        this.lastContext = context;\n\t        const clientSubscriptionStates = Array.from(this.clients.values());\n\t        clientSubscriptionStates.forEach((client) => {\n\t            // eslint-disable-next-line no-unused-expressions\n\t            client.contextHandlers.get(context.type)?.forEach((handlerId) => {\n\t                this.provider.dispatch(client.clientIdentity, handlerId, context);\n\t            });\n\t            if (client.globalHandler) {\n\t                this.provider.dispatch(client.clientIdentity, client.globalHandler, context);\n\t            }\n\t        });\n\t    }\n\t    getClientState(id) {\n\t        return this.clients.get(id.endpointId);\n\t    }\n\t    async handlerAdded(payload, clientIdentity) {\n\t        const { handlerId, contextType } = payload;\n\t        const clientSubscriptionState = this.getClientState(clientIdentity);\n\t        if (!clientSubscriptionState) {\n\t            throw new Error(`Client with Identity: ${clientIdentity.uuid} ${clientIdentity.name} not in Client State Map`);\n\t        }\n\t        if (contextType) {\n\t            const currentHandlerList = clientSubscriptionState.contextHandlers.get(contextType) || [];\n\t            clientSubscriptionState.contextHandlers.set(contextType, [...currentHandlerList, handlerId]);\n\t            const currentContext = this.contextGroupMap.get(contextType);\n\t            if (currentContext) {\n\t                await this.provider.dispatch(clientIdentity, handlerId, currentContext);\n\t            }\n\t        }\n\t        else {\n\t            clientSubscriptionState.globalHandler = handlerId;\n\t            const globalDispatchPromises = [...this.contextGroupMap.keys()].map(async (currentContextType) => {\n\t                const currentContext = this.contextGroupMap.get(currentContextType);\n\t                if (currentContext) {\n\t                    await this.provider.dispatch(clientIdentity, handlerId, currentContext);\n\t                }\n\t            });\n\t            await Promise.all(globalDispatchPromises);\n\t        }\n\t    }\n\t    handlerRemoved(payload, clientIdentity) {\n\t        const { handlerId } = payload;\n\t        const client = this.clients.get(clientIdentity.endpointId);\n\t        if (client) {\n\t            Array.from(client.contextHandlers).forEach(([, handlers]) => {\n\t                const index = handlers.indexOf(handlerId);\n\t                if (index > -1) {\n\t                    handlers.splice(index, 1);\n\t                }\n\t            });\n\t            if (client.globalHandler === handlerId) {\n\t                client.globalHandler = undefined;\n\t            }\n\t        }\n\t        else {\n\t            console.warn(`Trying to remove a handler from a client that isn't mapped. handlerId: ${handlerId}. clientIdentity: ${clientIdentity}`);\n\t        }\n\t    }\n\t    registerNewClient(clientIdentity) {\n\t        if (!this.clients.has(clientIdentity.endpointId)) {\n\t            const clientSubscriptionState = {\n\t                contextHandlers: new Map(),\n\t                clientIdentity,\n\t                globalHandler: undefined\n\t            };\n\t            this.clients.set(clientIdentity.endpointId, clientSubscriptionState);\n\t        }\n\t    }\n\t    onDisconnection(clientIdentity) {\n\t        this.clients.delete(clientIdentity.endpointId);\n\t    }\n\t};\n\tSessionContextGroupBroker.default = SessionContextGroupBroker$1;\n\treturn SessionContextGroupBroker;\n}\n\nvar utils$3 = {};\n\n(function (exports) {\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\texports.wrapIntentHandler = exports.BROKER_ERRORS = exports.generateOverrideWarning = exports.generateOverrideError = exports.wrapContextHandler = exports.wrapInTryCatch = exports.generateId = void 0;\n\tconst generateId = () => `${Math.random()}${Date.now()}`;\n\texports.generateId = generateId;\n\tconst wrapInTryCatch = (f, prefix) => (...args) => {\n\t    try {\n\t        return f(...args);\n\t    }\n\t    catch (e) {\n\t        throw new Error((prefix || '') + e);\n\t    }\n\t};\n\texports.wrapInTryCatch = wrapInTryCatch;\n\tconst wrapContextHandler = (handler, handlerId) => {\n\t    return async (context) => {\n\t        try {\n\t            await handler(context);\n\t        }\n\t        catch (error) {\n\t            console.error(`Error thrown by handler ${handlerId} for context type ${context.type}: ${error}`);\n\t            throw error;\n\t        }\n\t    };\n\t};\n\texports.wrapContextHandler = wrapContextHandler;\n\tconst generateOverrideError = (clientApi, brokerApi) => {\n\t    return `You have tried to to use ${clientApi} but ${brokerApi} has not been overridden in the Interop Broker. Please override this function. Refer to our documentation for more info.`;\n\t};\n\texports.generateOverrideError = generateOverrideError;\n\tconst generateOverrideWarning = (fdc3ClientApi, brokerApi, identity, interopClientApi) => {\n\t    const { uuid, name } = identity;\n\t    const message = interopClientApi\n\t        ? `Entity with identity: ${uuid}/${name} has called ${interopClientApi} or ${fdc3ClientApi} but ${brokerApi} has not been overridden.`\n\t        : `Entity with identity: ${uuid}/${name} has called ${fdc3ClientApi} but ${brokerApi} has not been overridden.`;\n\t    return message;\n\t};\n\texports.generateOverrideWarning = generateOverrideWarning;\n\texports.BROKER_ERRORS = {\n\t    fireIntent: (0, exports.generateOverrideError)('fireIntent', 'handleFiredIntent'),\n\t    fireIntentForContext: (0, exports.generateOverrideError)('fireIntentForContext', 'handleFiredIntentForContext'),\n\t    getInfoForIntent: (0, exports.generateOverrideError)('getInfoForIntent', 'handleInfoForIntent'),\n\t    getInfoForIntentsByContext: (0, exports.generateOverrideError)('getInfoForIntentsByContext', 'handleInfoForIntentsByContext'),\n\t    joinSessionContextGroupWithJoinContextGroup: 'The Context Group you have tried to join is a Session Context Group. Custom Context Groups can only be defined by the Interop Broker through code or manifest configuration. Please use joinSessionContextGroup.',\n\t    fdc3Open: (0, exports.generateOverrideError)('fdc3.open', 'fdc3HandleOpen'),\n\t    fdc3FindInstances: (0, exports.generateOverrideError)('fdc3.findInstances', 'fdc3HandleFindInstances'),\n\t    fdc3GetAppMetadata: (0, exports.generateOverrideError)('fdc3.getAppMetadata', 'fdc3HandleGetAppMetadata'),\n\t    fdc3GetInfo: (0, exports.generateOverrideError)('fdc3.getInfo', 'fdc3HandleGetInfo')\n\t};\n\tconst wrapIntentHandler = (handler, handlerId) => {\n\t    return async (intent) => {\n\t        try {\n\t            return handler(intent);\n\t        }\n\t        catch (error) {\n\t            console.error(`Error thrown by handler ${handlerId}: ${error}`);\n\t            throw error;\n\t        }\n\t    };\n\t};\n\texports.wrapIntentHandler = wrapIntentHandler; \n} (utils$3));\n\nvar PrivateChannelProvider = {};\n\nvar hasRequiredPrivateChannelProvider;\n\nfunction requirePrivateChannelProvider () {\n\tif (hasRequiredPrivateChannelProvider) return PrivateChannelProvider;\n\thasRequiredPrivateChannelProvider = 1;\n\tObject.defineProperty(PrivateChannelProvider, \"__esModule\", { value: true });\n\tPrivateChannelProvider.PrivateChannelProvider = void 0;\n\tconst InteropBroker_1 = requireInteropBroker();\n\tlet PrivateChannelProvider$1 = class PrivateChannelProvider {\n\t    constructor(provider, id) {\n\t        this.provider = provider;\n\t        this.id = id;\n\t        this.clients = new Map();\n\t        this.registerListeners();\n\t        this.contextByContextType = new Map();\n\t        this.lastContext = undefined;\n\t        this.provider.onConnection((clientIdentity) => this.registerNewClient(clientIdentity));\n\t        this.provider.onDisconnection(async (clientIdentity) => {\n\t            const { endpointId } = clientIdentity;\n\t            if (this.clients.has(endpointId)) {\n\t                await this.handleClientDisconnecting(clientIdentity);\n\t            }\n\t            if ((await this.provider.getAllClientInfo()).length === 0) {\n\t                this.provider.destroy();\n\t            }\n\t        });\n\t    }\n\t    getClientState(id) {\n\t        return this.clients.get(id.endpointId);\n\t    }\n\t    registerListeners() {\n\t        this.provider.register('broadcast', this.broadcast.bind(this));\n\t        this.provider.register('getCurrentContext', this.getCurrentContext.bind(this));\n\t        this.provider.register('contextHandlerAdded', this.contextHandlerAdded.bind(this));\n\t        this.provider.register('contextHandlerRemoved', this.contextHandlerRemoved.bind(this));\n\t        this.provider.register('nonStandardHandlerRemoved', this.nonStandardHandlerRemoved.bind(this));\n\t        this.provider.register('onAddContextHandlerAdded', this.onAddContextHandlerAdded.bind(this));\n\t        this.provider.register('onDisconnectHandlerAdded', this.onDisconnectHandlerAdded.bind(this));\n\t        this.provider.register('onUnsubscribeHandlerAdded', this.onUnsubscribeHandlerAdded.bind(this));\n\t        this.provider.register('clientDisconnecting', (payload, clientIdentity) => {\n\t            this.handleClientDisconnecting(clientIdentity);\n\t        });\n\t    }\n\t    broadcast(payload, broadcasterClientIdentity) {\n\t        const { context } = payload;\n\t        const broadcasterClientState = this.getClientState(broadcasterClientIdentity);\n\t        if (!broadcasterClientState) {\n\t            throw new Error(`Client with Identity: ${broadcasterClientIdentity.uuid} ${broadcasterClientIdentity.name}, tried to call broadcast, is not connected to this Private Channel`);\n\t        }\n\t        const contextIntegrityCheckResult = InteropBroker_1.InteropBroker.checkContextIntegrity(context);\n\t        if (contextIntegrityCheckResult.isValid === false) {\n\t            throw new Error(`Failed to broadcast - bad Context. Reason: ${contextIntegrityCheckResult.reason}. Context: ${JSON.stringify(context)}`);\n\t        }\n\t        this.contextByContextType.set(context.type, context);\n\t        this.lastContext = context;\n\t        Array.from(this.clients.values()).forEach((currClientState) => {\n\t            const handlerIdsForContextType = currClientState.handlerIdsByContextTypes.get(context.type);\n\t            if (handlerIdsForContextType) {\n\t                handlerIdsForContextType.forEach((handlerId) => {\n\t                    this.provider.dispatch(currClientState.clientIdentity, handlerId, context);\n\t                });\n\t            }\n\t            if (currClientState.globalHandler) {\n\t                this.provider.dispatch(currClientState.clientIdentity, currClientState.globalHandler, context);\n\t            }\n\t        });\n\t    }\n\t    getCurrentContext(payload, senderClientIdentity) {\n\t        const { contextType } = payload;\n\t        const clientState = this.getClientState(senderClientIdentity);\n\t        if (!clientState) {\n\t            throw new Error(`Client with Identity: ${senderClientIdentity.uuid} ${senderClientIdentity.name}, tried to call getCurrentContext, is not connected to this Private Channel`);\n\t        }\n\t        if (contextType !== undefined) {\n\t            const currentContext = this.contextByContextType.get(contextType);\n\t            if (currentContext)\n\t                return currentContext;\n\t            return null;\n\t        }\n\t        return this.lastContext ? this.lastContext : null;\n\t    }\n\t    contextHandlerAdded(payload, senderClientIdentity) {\n\t        const { handlerId, contextType } = payload;\n\t        const senderClientState = this.getClientState(senderClientIdentity);\n\t        if (!senderClientState) {\n\t            throw new Error(`Client with Identity: ${senderClientIdentity.uuid} ${senderClientIdentity.name}, tried to call addContextListener, is not connected to this Private Channel`);\n\t        }\n\t        if (contextType) {\n\t            const currentHandlersList = senderClientState.handlerIdsByContextTypes.get(contextType) || [];\n\t            senderClientState.handlerIdsByContextTypes.set(contextType, [...currentHandlersList, handlerId]);\n\t        }\n\t        else {\n\t            senderClientState.globalHandler = handlerId;\n\t        }\n\t        Array.from(this.clients.values()).forEach((currClientState) => {\n\t            if (currClientState.clientIdentity.endpointId !== senderClientIdentity.endpointId &&\n\t                currClientState.onAddContextListenerHandlerId) {\n\t                this.provider.dispatch(currClientState.clientIdentity, currClientState.onAddContextListenerHandlerId, contextType);\n\t            }\n\t        });\n\t    }\n\t    async contextHandlerRemoved(payload, removingClientIdentity) {\n\t        // MC: Made this removal async to ensure that onUnsubscribe handlers are hit before anything else happens.\n\t        const { handlerId } = payload;\n\t        const removingClientState = this.getClientState(removingClientIdentity);\n\t        if (removingClientState) {\n\t            let contextType;\n\t            if (removingClientState.globalHandler === handlerId) {\n\t                removingClientState.globalHandler = undefined;\n\t            }\n\t            else {\n\t                for (const [currContextType, handlersIds] of removingClientState.handlerIdsByContextTypes) {\n\t                    const index = handlersIds.indexOf(handlerId);\n\t                    if (index > -1) {\n\t                        handlersIds.splice(index, 1);\n\t                        contextType = currContextType;\n\t                    }\n\t                }\n\t            }\n\t            // getting only valid client connections here, it is possible we haven't removed a disconnected client from the map yet\n\t            // so we need to ensure we don't dispatch to any disconnected client\n\t            // TODO: Take a look at our client disconnection logic and see if we can handle client disconnection cleanly\n\t            const clientsToDispatchTo = await this.getConnectedClients();\n\t            const dispatchPromises = clientsToDispatchTo.map(async (otherClientState) => {\n\t                const { clientIdentity, clientIdentity: { endpointId }, onUnsubscribeHandlerId } = otherClientState;\n\t                if (endpointId !== removingClientIdentity.endpointId && onUnsubscribeHandlerId) {\n\t                    await this.provider.dispatch(clientIdentity, onUnsubscribeHandlerId, contextType);\n\t                }\n\t            });\n\t            try {\n\t                await Promise.all(dispatchPromises);\n\t            }\n\t            catch (error) {\n\t                console.error(`Problem when attempting to dispatch to onUnsubscribeHandlers. Error: ${error} Removing Client: ${handlerId}. uuid: ${removingClientIdentity.uuid}. name: ${removingClientIdentity.name}. endpointId: ${removingClientIdentity.endpointId}`);\n\t                throw new Error(error);\n\t            }\n\t        }\n\t        else {\n\t            console.warn(`Trying to remove a handler from a client that isn't mapped. handlerId: ${handlerId}. uuid: ${removingClientIdentity.uuid}. name: ${removingClientIdentity.name}. endpointId: ${removingClientIdentity.endpointId}.`);\n\t        }\n\t    }\n\t    nonStandardHandlerRemoved(payload, id) {\n\t        const { handlerId } = payload;\n\t        const clientState = this.getClientState(id);\n\t        if (clientState) {\n\t            if (clientState.onDisconnectHandlerId === handlerId) {\n\t                clientState.onDisconnectHandlerId = undefined;\n\t            }\n\t            else if (clientState.onAddContextListenerHandlerId === handlerId) {\n\t                clientState.onAddContextListenerHandlerId = undefined;\n\t            }\n\t            else if (clientState.onUnsubscribeHandlerId === handlerId) {\n\t                clientState.onUnsubscribeHandlerId = undefined;\n\t            }\n\t        }\n\t        else {\n\t            console.warn(`Trying to remove a handler from a client that isn't mapped. handlerId: ${handlerId}. clientIdentity: ${id}`);\n\t        }\n\t    }\n\t    onAddContextHandlerAdded(payload, senderClientIdentity) {\n\t        const clientState = this.getClientState(senderClientIdentity);\n\t        const { handlerId } = payload;\n\t        if (!clientState) {\n\t            throw new Error(`Client with Identity: ${senderClientIdentity.uuid} ${senderClientIdentity.name}, tried to call onAddContextListener, is not connected to this Private Channel`);\n\t        }\n\t        clientState.onAddContextListenerHandlerId = handlerId;\n\t        // FDC3 Spec says that the added listener should fire for all previously-registered addContextListeners from the other client\n\t        Array.from(this.clients.values()).forEach((otherClientState) => {\n\t            if (otherClientState.clientIdentity.endpointId !== senderClientIdentity.endpointId) {\n\t                Array.from(otherClientState.handlerIdsByContextTypes.keys()).forEach((subscribedContextType) => {\n\t                    this.provider.dispatch(senderClientIdentity, handlerId, subscribedContextType);\n\t                });\n\t            }\n\t        });\n\t    }\n\t    onDisconnectHandlerAdded(payload, id) {\n\t        const clientState = this.getClientState(id);\n\t        const { handlerId } = payload;\n\t        if (!clientState) {\n\t            throw new Error(`Client with Identity: ${id.uuid} ${id.name}, tried to call onDisconnect, is not connected to this Private Channel`);\n\t        }\n\t        clientState.onDisconnectHandlerId = handlerId;\n\t    }\n\t    onUnsubscribeHandlerAdded(payload, id) {\n\t        const clientState = this.getClientState(id);\n\t        const { handlerId } = payload;\n\t        if (!clientState) {\n\t            throw new Error(`Client with Identity: ${id.uuid} ${id.name}, tried to call onUnsubscribe, is not connected to this Private Channel`);\n\t        }\n\t        clientState.onUnsubscribeHandlerId = handlerId;\n\t    }\n\t    removeClient(disconnectingClientIdentity) {\n\t        const disconnectingClientState = this.getClientState(disconnectingClientIdentity);\n\t        if (!disconnectingClientState) {\n\t            throw new Error(`Client with Identity: ${disconnectingClientIdentity.uuid} ${disconnectingClientIdentity.name}, tried to call disconnect, is not connected to this Private Channel`);\n\t        }\n\t        disconnectingClientState.handlerIdsByContextTypes.clear();\n\t        this.clients.delete(disconnectingClientIdentity.endpointId);\n\t    }\n\t    async fireOnDisconnectForOtherClients(disconnectingClientIdentity) {\n\t        // TODO: call onDisconnect Handler of the other client only.\n\t        // CURRENTLY, just calling the onDisconnect handler for all the other clients. Once we limit it to just one other client, we can eliminate all the iteration code.\n\t        const { endpointId } = disconnectingClientIdentity;\n\t        // getting only valid client connections here, it is possible we haven't removed a disconnected client from the map yet\n\t        // so we need to ensure we don't dispatch to any disconnected client\n\t        // TODO: Take a look at our client disconnection logic and see if we can handle client disconnection cleanly\n\t        const clientsToDispatchTo = await this.getConnectedClients();\n\t        const dispatchPromises = clientsToDispatchTo.map(async (otherClientState) => {\n\t            const { clientIdentity: { endpointId: otherClientEndpointId }, onDisconnectHandlerId } = otherClientState;\n\t            if (otherClientEndpointId !== endpointId && onDisconnectHandlerId) {\n\t                await this.provider.dispatch(otherClientState.clientIdentity, onDisconnectHandlerId);\n\t            }\n\t        });\n\t        try {\n\t            await Promise.all(dispatchPromises);\n\t        }\n\t        catch (error) {\n\t            console.error(`Problem when attempting to dispatch to onDisconnectHandlers. Error: ${error} Disconnecting Client: uuid: ${disconnectingClientIdentity.uuid}. name: ${disconnectingClientIdentity.name}. endpointId: ${disconnectingClientIdentity.endpointId}`);\n\t            throw new Error(error);\n\t        }\n\t    }\n\t    async unsubscribeAll(clientIdentity) {\n\t        const { endpointId } = clientIdentity;\n\t        const state = this.clients.get(endpointId);\n\t        if (state) {\n\t            const contextTypeHandlerIds = Array.from(state.handlerIdsByContextTypes.values()).flat();\n\t            const globalHandlerId = state.globalHandler;\n\t            if (contextTypeHandlerIds.length > 0) {\n\t                const unsubPromises = contextTypeHandlerIds.map(async (handlerId) => {\n\t                    return this.contextHandlerRemoved({ handlerId }, clientIdentity);\n\t                });\n\t                try {\n\t                    await Promise.all(unsubPromises);\n\t                }\n\t                catch (error) {\n\t                    console.error(error.message);\n\t                }\n\t            }\n\t            if (globalHandlerId) {\n\t                try {\n\t                    await this.contextHandlerRemoved({ handlerId: globalHandlerId }, clientIdentity);\n\t                }\n\t                catch (error) {\n\t                    console.error(error.message);\n\t                }\n\t            }\n\t        }\n\t    }\n\t    async handleClientDisconnecting(disconnectingClientIdentity) {\n\t        await this.unsubscribeAll(disconnectingClientIdentity);\n\t        this.removeClient(disconnectingClientIdentity);\n\t        await this.fireOnDisconnectForOtherClients(disconnectingClientIdentity);\n\t    }\n\t    registerNewClient(clientIdentity) {\n\t        if (!this.clients.has(clientIdentity.endpointId)) {\n\t            const clientSubscriptionState = {\n\t                clientIdentity,\n\t                handlerIdsByContextTypes: new Map(),\n\t                globalHandler: undefined,\n\t                onAddContextListenerHandlerId: undefined,\n\t                onUnsubscribeHandlerId: undefined,\n\t                onDisconnectHandlerId: undefined\n\t            };\n\t            this.clients.set(clientIdentity.endpointId, clientSubscriptionState);\n\t        }\n\t    }\n\t    async getConnectedClients() {\n\t        const allClientInfo = await this.provider.getAllClientInfo();\n\t        return Array.from(this.clients.values()).filter((clientState) => {\n\t            const { uuid, name } = clientState.clientIdentity;\n\t            return allClientInfo.some((clientInfo) => {\n\t                return name === clientInfo.name && uuid === clientInfo.uuid;\n\t            });\n\t        });\n\t    }\n\t    static init(channelProvider, id) {\n\t        return new PrivateChannelProvider(channelProvider, id);\n\t    }\n\t};\n\tPrivateChannelProvider.PrivateChannelProvider = PrivateChannelProvider$1;\n\treturn PrivateChannelProvider;\n}\n\nvar hasRequiredInteropBroker;\n\nfunction requireInteropBroker () {\n\tif (hasRequiredInteropBroker) return InteropBroker;\n\thasRequiredInteropBroker = 1;\n\tvar __classPrivateFieldSet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n\t    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n\t    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n\t    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n\t    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n\t};\n\tvar __classPrivateFieldGet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n\t    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n\t    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n\t    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n\t};\n\tvar __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {\n\t    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n\t};\n\tvar _InteropBroker_fdc3Info, _InteropBroker_contextGroups, _InteropBroker_providerPromise;\n\tObject.defineProperty(InteropBroker, \"__esModule\", { value: true });\n\tInteropBroker.InteropBroker = void 0;\n\tconst base_1 = base;\n\tconst SessionContextGroupBroker_1 = __importDefault(requireSessionContextGroupBroker());\n\tconst utils_1 = utils$3;\n\tconst isEqual_1 = __importDefault(require$$3);\n\tconst PrivateChannelProvider_1 = requirePrivateChannelProvider();\n\tconst lazy_1 = lazy;\n\tconst defaultContextGroups = [\n\t    {\n\t        id: 'green',\n\t        displayMetadata: {\n\t            color: '#00CC88',\n\t            name: 'green'\n\t        }\n\t    },\n\t    {\n\t        id: 'purple',\n\t        displayMetadata: {\n\t            color: '#8C61FF',\n\t            name: 'purple'\n\t        }\n\t    },\n\t    {\n\t        id: 'orange',\n\t        displayMetadata: {\n\t            color: '#FF8C4C',\n\t            name: 'orange'\n\t        }\n\t    },\n\t    {\n\t        id: 'red',\n\t        displayMetadata: {\n\t            color: '#FF5E60',\n\t            name: 'red'\n\t        }\n\t    },\n\t    {\n\t        id: 'pink',\n\t        displayMetadata: {\n\t            color: '#FF8FB8',\n\t            name: 'pink'\n\t        }\n\t    },\n\t    {\n\t        id: 'yellow',\n\t        displayMetadata: {\n\t            color: '#E9FF8F',\n\t            name: 'yellow'\n\t        }\n\t    }\n\t];\n\t/**\n\t * {@link https://developers.openfin.co/of-docs/docs/enable-color-linking}\n\t *\n\t * The Interop Broker is responsible for keeping track of the Interop state of the Platform, and for directing messages to the proper locations.\n\t *\n\t * @remarks This class contains some types related to FDC3 that are specific to OpenFin. {@link https://developers.openfin.co/of-docs/docs/fdc3-support-in-openfin OpenFin's FDC3 support} is forward- and backward-compatible.\n\t * Standard types for {@link https://fdc3.finos.org/ FDC3} do not appear in OpenFin’s API documentation, to avoid duplication.\n\t *\n\t * ---\n\t *\n\t * There are 2 ways to inject custom functionality into the Interop Broker:\n\t *\n\t * **1. Configuration**\n\t *\n\t * At the moment, you can configure the default context groups for the Interop Broker without having to override it. To do so, include the `interopBrokerConfiguration` `contextGroups` option in your `platform` options in your manifest. This is the preferred method.\n\t * ```js\n\t * {\n\t *      \"runtime\": {\n\t *          \"arguments\": \"--v=1 --inspect\",\n\t *          \"version\": \"alpha-v19\"\n\t *      },\n\t *      \"platform\": {\n\t *          \"uuid\": \"platform_customization_local\",\n\t *          \"applicationIcon\": \"https://openfin.github.io/golden-prototype/favicon.ico\",\n\t *          \"autoShow\": false,\n\t *          \"providerUrl\": \"http://localhost:5555/provider.html\",\n\t *          \"interopBrokerConfiguration\": {\n\t *              \"contextGroups\": [\n\t *                  {\n\t *                      \"id\": \"green\",\n\t *                      \"displayMetadata\": {\n\t *                          \"color\": \"#00CC88\",\n\t *                          \"name\": \"green\"\n\t *                      }\n\t *                  },\n\t *                  {\n\t *                      \"id\": \"purple\",\n\t *                      \"displayMetadata\": {\n\t *                          \"color\": \"#8C61FF\",\n\t *                          \"name\": \"purple\"\n\t *                      }\n\t *                  },\n\t *              ]\n\t *          }\n\t *      }\n\t * }\n\t * ```\n\t *\n\t * By default the Interop Broker logs all actions to the console. You can disable this by using the logging option in `interopBrokerConfiguration`:\n\t * ```js\n\t * {\n\t *      \"runtime\": {\n\t *          \"arguments\": \"--v=1 --inspect\",\n\t *          \"version\": \"alpha-v19\"\n\t *      },\n\t *      \"platform\": {\n\t *          \"uuid\": \"platform_customization_local\",\n\t *          \"applicationIcon\": \"https://openfin.github.io/golden-prototype/favicon.ico\",\n\t *          \"autoShow\": false,\n\t *          \"providerUrl\": \"http://localhost:5555/provider.html\",\n\t *\t\t    \"interopBrokerConfiguration\": {\n\t *       \t\t\"logging\": {\n\t *   \t\t\t\t\"beforeAction\": {\n\t *   \t\t\t\t\t\"enabled\": false\n\t *   \t\t\t\t},\n\t *   \t\t\t\t\"afterAction\": {\n\t *   \t\t\t\t\t\"enabled\": false\n\t *   \t\t\t\t}\n\t *   \t\t\t}\n\t *\t\t    }\n\t *      }\n\t * }\n\t * ```\n\t *\n\t * ---\n\t * **2. Overriding**\n\t *\n\t * Similarly to how {@link https://developers.openfin.co/docs/platform-customization#section-customizing-platform-behavior Platform Overriding} works, you can override functions in the Interop Broker in `fin.Platform.init`. An example of that is shown below. Overriding `isConnectionAuthorized` and `isActionAuthorized` will allow you to control allowed connections and allowed actions.\n\t *\n\t * However, if there is custom functionality you wish to include in the Interop Broker, please let us know. We would like to provide better configuration options so that you don't have to continually maintain your own override code.\n\t *\n\t * ```js\n\t * fin.Platform.init({\n\t *     overrideCallback: async (Provider) => {\n\t *         class Override extends Provider {\n\t *             async getSnapshot() {\n\t *                 console.log('before getSnapshot')\n\t *                 const snapshot = await super.getSnapshot();\n\t *                 console.log('after getSnapshot')\n\t *                 return snapshot;\n\t *             }\n\t *\n\t *             async applySnapshot({ snapshot, options }) {\n\t *                 console.log('before applySnapshot')\n\t *                 const originalPromise = super.applySnapshot({ snapshot, options });\n\t *                 console.log('after applySnapshot')\n\t *\n\t *                 return originalPromise;\n\t *             }\n\t *         };\n\t *         return new Override();\n\t *     },\n\t *     interopOverride: async (InteropBroker) => {\n\t *         class Override extends InteropBroker {\n\t *             async joinContextGroup(channelName = 'default', target) {\n\t *                 console.log('before super joinContextGroup')\n\t *                 super.joinContextGroup(channelName, target);\n\t *                 console.log('after super joinContextGroup')\n\t *             }\n\t *         }\n\t *\n\t *       return new Override();\n\t *   }\n\t * });\n\t * ```\n\t *\n\t * ---\n\t *\n\t */\n\tlet InteropBroker$1 = class InteropBroker extends base_1.Base {\n\t    /**\n\t     * @internal\n\t     */\n\t    constructor(wire, createProvider, options) {\n\t        // Tip from Pierre and Michael from the overrideCheck work: Don't use bound methods for overrideable InteropBroker functions.\n\t        super(wire);\n\t        _InteropBroker_fdc3Info.set(this, void 0);\n\t        _InteropBroker_contextGroups.set(this, void 0);\n\t        _InteropBroker_providerPromise.set(this, void 0);\n\t        this.getProvider = () => {\n\t            return __classPrivateFieldGet(this, _InteropBroker_providerPromise, \"f\").getValue();\n\t        };\n\t        this.interopClients = new Map();\n\t        this.contextGroupsById = new Map();\n\t        __classPrivateFieldSet(this, _InteropBroker_contextGroups, options.contextGroups ?? [...defaultContextGroups], \"f\");\n\t        __classPrivateFieldSet(this, _InteropBroker_fdc3Info, options.fdc3Info, \"f\");\n\t        if (options?.logging) {\n\t            this.logging = options.logging;\n\t        }\n\t        this.intentClientMap = new Map();\n\t        this.lastContextMap = new Map();\n\t        this.sessionContextGroupMap = new Map();\n\t        __classPrivateFieldSet(this, _InteropBroker_providerPromise, new lazy_1.Lazy(createProvider), \"f\");\n\t        this.setContextGroupMap();\n\t        this.setupChannelProvider();\n\t    }\n\t    static createClosedConstructor(...args) {\n\t        return class OverrideableBroker extends InteropBroker {\n\t            constructor(...unused) {\n\t                if (unused.length) {\n\t                    const [_ignore1, ignore2, opts] = unused;\n\t                    if (opts && typeof opts === 'object' && !(0, isEqual_1.default)(opts, args[2])) {\n\t                        // eslint-disable-next-line no-console\n\t                        console.warn('You have modified the parameters of the InteropOverride constructor. This behavior is deprecated and will be removed in a future version. You can modify these options in your manifest. Please consult our Interop docs for guidance on migrating to the new override scheme.');\n\t                        super(args[0], args[1], opts);\n\t                        return;\n\t                    }\n\t                    // eslint-disable-next-line no-console\n\t                    console.warn('You are attempting to pass arguments to the InteropOverride constructor. This is not necessary, and these passed arguments will be ignored. You are likely using an older InteropBroker override scheme. Please consult our Interop docs for guidance on migrating to the new override scheme.');\n\t                }\n\t                super(...args);\n\t            }\n\t        };\n\t    }\n\t    /*\n\t    Client API\n\t    */\n\t    /**\n\t     * Sets a context for the context group of the incoming current entity.\n\t     * @param setContextOptions - New context to set.\n\t     * @param clientIdentity - Identity of the client sender.\n\t     *\n\t     */\n\t    setContext({ context }, clientIdentity) {\n\t        this.wire.sendAction('interop-broker-set-context').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const clientState = this.getClientState(clientIdentity);\n\t        if (clientState && clientState.contextGroupId) {\n\t            const { contextGroupId } = clientState;\n\t            this.setContextForGroup({ context }, contextGroupId);\n\t        }\n\t        else if (clientState) {\n\t            // Client has not joined any context group behavior.\n\t            throw new Error('You must join a context group before you can set context.');\n\t        }\n\t        else {\n\t            // This shouldn't get hit.\n\t            throw new Error(`Client with Identity: ${clientIdentity.uuid} ${clientIdentity.name} not in Client State Map`);\n\t        }\n\t    }\n\t    /**\n\t     * Sets a context for the context group.\n\t     * @param setContextOptions - New context to set.\n\t     * @param contextGroupId - Context group id.\n\t     *\n\t     */\n\t    setContextForGroup({ context }, contextGroupId) {\n\t        this.wire.sendAction('interop-broker-set-context-for-group').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const contextGroupState = this.contextGroupsById.get(contextGroupId);\n\t        if (!contextGroupState) {\n\t            throw new Error(`Unable to set context for context group that isn't in the context group mapping: ${contextGroupId}.`);\n\t        }\n\t        const contextIntegrityCheckResult = InteropBroker.checkContextIntegrity(context);\n\t        if (contextIntegrityCheckResult.isValid === false) {\n\t            throw new Error(`Failed to set Context - bad Context. Reason: ${contextIntegrityCheckResult.reason}. Context: ${JSON.stringify(context)}`);\n\t        }\n\t        const broadcastedContextType = context.type;\n\t        contextGroupState.set(broadcastedContextType, context);\n\t        this.lastContextMap.set(contextGroupId, broadcastedContextType);\n\t        const clientsInSameContextGroup = Array.from(this.interopClients.values()).filter((connectedClient) => connectedClient.contextGroupId === contextGroupId);\n\t        clientsInSameContextGroup.forEach((client) => {\n\t            for (const [, handlerInfo] of client.contextHandlers) {\n\t                if (InteropBroker.isContextTypeCompatible(broadcastedContextType, handlerInfo.contextType)) {\n\t                    this.invokeContextHandler(client.clientIdentity, handlerInfo.handlerId, context);\n\t                }\n\t            }\n\t        });\n\t    }\n\t    /**\n\t     * Get current context for a client subscribed to a Context Group.\n\t     *\n\t     * @remarks It takes an optional Context Type argument and returns the last context of that type.\n\t     *\n\t     * @param getContextOptions - Options for getting context\n\t     * @param clientIdentity - Identity of the client sender.\n\t     *\n\t     */\n\t    getCurrentContext(getCurrentContextOptions, clientIdentity) {\n\t        this.wire.sendAction('interop-broker-get-current-context').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const clientState = this.getClientState(clientIdentity);\n\t        if (!clientState?.contextGroupId) {\n\t            throw new Error('You must be a member of a context group to call getCurrentContext');\n\t        }\n\t        const { contextGroupId } = clientState;\n\t        const contextGroupState = this.contextGroupsById.get(contextGroupId);\n\t        const lastContextType = this.lastContextMap.get(contextGroupId);\n\t        const contextType = getCurrentContextOptions?.contextType ?? lastContextType;\n\t        return contextGroupState && contextType ? contextGroupState.get(contextType) : undefined;\n\t    }\n\t    /*\n\t    Platform Window APIs\n\t    */\n\t    // joinContextGroup and addClientToContextGroup are separate functions here, for easier overrides and separation of concerns.\n\t    // joinContextGroup checks all connections for matching identities, in case we have multiple connection from an entity.\n\t    /**\n\t     * Join all connections at the given identity (or just one if endpointId provided) to context group `contextGroupId`.\n\t     * If no target is specified, it adds the sender to the context group.\n\t     * joinContextGroup is responsible for checking connections at the incoming identity. It calls {@link InteropBroker#addClientToContextGroup InteropBroker.addClientToContextGroup} to actually group the client.\n\t     * Used by Platform Windows.\n\t     *\n\t     * @param joinContextGroupOptions - Id of the Context Group and identity of the entity to join to the group.\n\t     * @param senderIdentity - Identity of the client sender.\n\t     */\n\t    async joinContextGroup({ contextGroupId, target }, senderIdentity) {\n\t        this.wire.sendAction('interop-broker-join-context-group').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        if (this.sessionContextGroupMap.has(contextGroupId)) {\n\t            throw new Error(utils_1.BROKER_ERRORS.joinSessionContextGroupWithJoinContextGroup);\n\t        }\n\t        if (target) {\n\t            // If an endpointId is provided, use that. This will likely be used by external adapters.\n\t            if (InteropBroker.hasEndpointId(target)) {\n\t                await this.addClientToContextGroup({ contextGroupId }, target);\n\t            }\n\t            // Sanity check here in case a single app has multiple connections\n\t            try {\n\t                const allConnections = this.channel.connections.filter((x) => x.uuid === target.uuid && x.name === target.name);\n\t                if (!allConnections.length) {\n\t                    throw new Error(`Given Identity ${target.uuid} ${target.name} is not connected to the Interop Broker.`);\n\t                }\n\t                if (allConnections.length > 1) {\n\t                    // Should figure out how we want to handle this situation. In the meantime, just change context group for all connections.\n\t                    console.warn(`More than one connection found for identity ${target.uuid} ${target.name}`);\n\t                }\n\t                const promises = [];\n\t                for (const connection of allConnections) {\n\t                    promises.push(this.addClientToContextGroup({ contextGroupId }, connection));\n\t                }\n\t                await Promise.all(promises);\n\t            }\n\t            catch (error) {\n\t                throw new Error(error);\n\t            }\n\t        }\n\t        else {\n\t            // No target provided, add the sender to the context group.\n\t            await this.addClientToContextGroup({ contextGroupId }, senderIdentity);\n\t        }\n\t    }\n\t    // addClientToContextGroup does the actual addition of the client to the Context Group\n\t    /**\n\t     * Helper function for {@link InteropBroker#joinContextGroup InteropBroker.joinContextGroup}. Does the work of actually adding the client to the Context Group.\n\t     * Used by Platform Windows.\n\t     *\n\t     * @param addClientToContextGroupOptions - Contains the contextGroupId\n\t     * @param clientIdentity - Identity of the client sender.\n\t     */\n\t    async addClientToContextGroup({ contextGroupId }, clientIdentity) {\n\t        this.wire.sendAction('interop-broker-add-client-to-context-group').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const clientSubscriptionState = this.getClientState(clientIdentity);\n\t        if (!clientSubscriptionState) {\n\t            throw new Error(`Client with Identity: ${clientIdentity.uuid} ${clientIdentity.name} not in Client State Map`);\n\t        }\n\t        if (!this.getContextGroups().find((contextGroupInfo) => contextGroupInfo.id === contextGroupId)) {\n\t            throw new Error(`Attempting to join a context group that does not exist: ${contextGroupId}. You may only join existing context groups.`);\n\t        }\n\t        const oldContextGroupId = clientSubscriptionState.contextGroupId;\n\t        if (oldContextGroupId !== contextGroupId) {\n\t            clientSubscriptionState.contextGroupId = contextGroupId;\n\t            await this.setCurrentContextGroupInClientOptions(clientIdentity, contextGroupId);\n\t            const contextGroupMap = this.contextGroupsById.get(contextGroupId);\n\t            for (const [, handlerInfo] of clientSubscriptionState.contextHandlers) {\n\t                const { contextType, handlerId } = handlerInfo;\n\t                if (contextType === undefined) {\n\t                    // Send this single handler all of the context, because it accepts all.\n\t                    contextGroupMap.forEach((context, _) => {\n\t                        this.invokeContextHandler(clientIdentity, handlerId, context);\n\t                    });\n\t                }\n\t                else if (contextGroupMap.has(contextType)) {\n\t                    const contextForType = contextGroupMap.get(contextType);\n\t                    if (contextForType) {\n\t                        this.invokeContextHandler(clientIdentity, handlerId, contextForType);\n\t                    }\n\t                }\n\t            }\n\t        }\n\t    }\n\t    // Removes the target from its context group. Similar structure to joinContextGroup.\n\t    /**\n\t     * Removes the specified target from a context group.\n\t     * If no target is specified, it removes the sender from their context group.\n\t     * removeFromContextGroup is responsible for checking connections at the incoming identity.\n\t     *\n\t     * @remarks It calls {@link InteropBroker#removeClientFromContextGroup InteropBroker.removeClientFromContextGroup} to actually ungroup\n\t     * the client. Used by Platform Windows.\n\t     *\n\t     * @param removeFromContextGroupOptions - Contains the target identity to remove.\n\t     * @param senderIdentity - Identity of the client sender.\n\t     */\n\t    async removeFromContextGroup({ target }, senderIdentity) {\n\t        this.wire.sendAction('interop-broker-remove-from-context-group').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        if (target) {\n\t            // If an endpointId is provided, use that. This will likely be used by external adapters.\n\t            if (InteropBroker.hasEndpointId(target)) {\n\t                await this.removeClientFromContextGroup(target);\n\t            }\n\t            try {\n\t                // Sanity check here in case a single app has multiple connections\n\t                const allConnections = this.channel.connections.filter((x) => x.uuid === target.uuid && x.name === target.name);\n\t                if (!allConnections.length) {\n\t                    throw new Error(`No connection found for given Identity ${target.uuid} ${target.name}`);\n\t                }\n\t                if (allConnections.length > 1) {\n\t                    console.warn(`More than one connection found for identity ${target.uuid} ${target.name}`);\n\t                }\n\t                const promises = [];\n\t                for (const connection of allConnections) {\n\t                    promises.push(this.removeClientFromContextGroup(connection));\n\t                }\n\t                await Promise.all(promises);\n\t            }\n\t            catch (error) {\n\t                throw new Error(error);\n\t            }\n\t        }\n\t        else {\n\t            // No target provided, remove the sender from the context group.\n\t            await this.removeClientFromContextGroup(senderIdentity);\n\t        }\n\t    }\n\t    // removeClientFromContextGroup does the actual remove of the client from the Context Group\n\t    /**\n\t     * Helper function for {@link InteropBroker#removeFromContextGroup InteropBroker.removeFromContextGroup}. Does the work of actually removing the client from the Context Group.\n\t     * Used by Platform Windows.\n\t     *\n\t     * @property { ClientIdentity } clientIdentity - Identity of the client sender.\n\t     */\n\t    async removeClientFromContextGroup(clientIdentity) {\n\t        this.wire.sendAction('interop-broker-remove-client-from-context-group').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const clientState = this.getClientState(clientIdentity);\n\t        if (clientState) {\n\t            clientState.contextGroupId = undefined;\n\t        }\n\t        await this.setCurrentContextGroupInClientOptions(clientIdentity, null);\n\t    }\n\t    // Used by platform windows to know what client groups the provider has declared. Also used internally to access context groups. Overrideable so that the platform developer can modify it.\n\t    /**\n\t     * Returns the Interop-Broker-defined context groups available for an entity to join. Because this function is used in the rest of the Interop Broker to fetch the Context Groups, overriding this allows you to customize the Context Groups for the Interop Broker. However, we recommend customizing the context groups through configuration instead.\n\t     * Used by Platform Windows.\n\t     *\n\t     */\n\t    // eslint-disable-next-line class-methods-use-this\n\t    getContextGroups() {\n\t        this.wire.sendAction('interop-broker-get-context-groups').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        // Create copy for immutability\n\t        return __classPrivateFieldGet(this, _InteropBroker_contextGroups, \"f\").map((contextGroup) => {\n\t            return { ...contextGroup };\n\t        });\n\t    }\n\t    // Used to by platform windows to get display metadata for a context group.\n\t    /**\n\t     * Gets display info for a context group\n\t     *\n\t     * @remarks Used by Platform Windows.\n\t     *\n\t     * @param getInfoForContextGroupOptions - Contains contextGroupId, the context group you wish to get display info for.\n\t     *\n\t     */\n\t    getInfoForContextGroup({ contextGroupId }) {\n\t        this.wire.sendAction('interop-broker-get-info-for-context-group').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        return this.getContextGroups().find((contextGroup) => contextGroup.id === contextGroupId);\n\t    }\n\t    // Used by platform windows to get all clients for a context group.\n\t    /**\n\t     * Gets all clients for a context group.\n\t     *\n\t     * @remarks **This is primarily used for platform windows. Views within a platform should not have to use this API.**\n\t     * Returns the Interop-Broker-defined context groups available for an entity to join.\n\t     *\n\t     * @param getAllClientsInContextGroupOptions - Contains contextGroupId, the context group you wish to get clients for.\n\t     *\n\t     */\n\t    getAllClientsInContextGroup({ contextGroupId }) {\n\t        this.wire.sendAction('interop-broker-get-all-clients-in-context-group').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const clientsInContextGroup = Array.from(this.interopClients.values())\n\t            .filter((connectedClient) => connectedClient.contextGroupId === contextGroupId)\n\t            .map((subscriptionState) => {\n\t            return subscriptionState.clientIdentity;\n\t        });\n\t        return clientsInContextGroup;\n\t    }\n\t    /**\n\t     * Responsible for launching of applications that can handle a given intent, and delegation of intents to those applications.\n\t     * Must be overridden.\n\t     *\n\t     * @remarks To make this call FDC3-Compliant it would need to return an IntentResolution.\n\t     *\n\t     * ```js\n\t     * interface IntentResolution {\n\t     *   source: TargetApp;\n\t     *   // deprecated, not assignable from intent listeners\n\t     *   data?: object;\n\t     *   version: string;\n\t     * }\n\t     * ```\n\t     *\n\t     * More information on the IntentResolution type can be found in the [FDC3 documentation](https://fdc3.finos.org/docs/api/ref/IntentResolution).\n\t     *\n\t     * @param intent The combination of an action and a context that is passed to an application for resolution.\n\t     * @param  clientIdentity Identity of the Client making the request.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * // override call so we set intent target and create view that will handle it\n\t     * fin.Platform.init({\n\t     *     interopOverride: async (InteropBroker) => {\n\t     *         class Override extends InteropBroker {\n\t     *             async handleFiredIntent(intent) {\n\t     *                 super.setIntentTarget(intent, { uuid: 'platform-uuid', name: 'intent-view' });\n\t     *                 const platform = fin.Platform.getCurrentSync();\n\t     *                 const win = fin.Window.wrapSync({ name: 'foo', uuid: 'platform-uuid' });\n\t     *                 const createdView = await platform.createView({ url: 'http://openfin.co', name: 'intent-view' }, win.identity);\n\t     *             }\n\t     *         }\n\t     *         return new Override();\n\t     *     }\n\t     * });\n\t     * ```\n\t     */\n\t    // eslint-disable-next-line class-methods-use-this\n\t    async handleFiredIntent(intent, clientIdentity // TODO(CORE-811): remove inline intersected type\n\t    ) {\n\t        const warning = (0, utils_1.generateOverrideWarning)('fdc3.raiseIntent', 'InteropBroker.handleFiredIntent', clientIdentity, 'interopClient.fireIntent');\n\t        console.warn(warning);\n\t        throw new Error(utils_1.BROKER_ERRORS.fireIntent);\n\t    }\n\t    /**\n\t     * Should be called in {@link InteropBroker#handleFiredIntent InteropBroker.handleFiredIntent}.\n\t     * While handleFiredIntent is responsible for launching applications, setIntentTarget is used to tell the InteropBroker which application should receive the intent when it is ready.\n\t     * @param intent The combination of an action and a context that is passed to an application for resolution.\n\t     * @param target - Identity of the target that will handle the intent.\n\t     *\n\t     */\n\t    async setIntentTarget(intent, target) {\n\t        this.wire.sendAction('interop-broker-set-intent-target').catch((e) => {\n\t            // don't expose, this is only for api analytics purposes\n\t        });\n\t        const targetInfo = this.intentClientMap.get(target.name);\n\t        const handlerId = `intent-handler-${intent.name}`;\n\t        if (!targetInfo) {\n\t            this.intentClientMap.set(target.name, new Map());\n\t            const newHandlerInfoMap = this.intentClientMap.get(target.name);\n\t            if (newHandlerInfoMap) {\n\t                newHandlerInfoMap.set(handlerId, { isReady: false, pendingIntents: [intent] });\n\t            }\n\t        }\n\t        else {\n\t            const handlerInfo = targetInfo.get(handlerId);\n\t            if (!handlerInfo) {\n\t                targetInfo.set(handlerId, { isReady: false, pendingIntents: [intent] });\n\t            }\n\t            else {\n\t                handlerInfo.pendingIntents.push(intent);\n\t                if (handlerInfo.clientIdentity && handlerInfo.isReady) {\n\t                    const { clientIdentity, pendingIntents } = handlerInfo;\n\t                    try {\n\t                        const intentToSend = pendingIntents[pendingIntents.length - 1];\n\t                        await this.invokeIntentHandler(clientIdentity, handlerId, intentToSend);\n\t                        handlerInfo.pendingIntents = [];\n\t                    }\n\t                    catch (error) {\n\t                        console.error(`Error invoking intent handler for client ${clientIdentity.uuid}/${clientIdentity.name}/${clientIdentity.endpointId}`);\n\t                        handlerInfo.isReady = false;\n\t                    }\n\t                }\n\t            }\n\t        }\n\t    }\n\t    /**\n\t     * Responsible for returning information on a particular Intent.\n\t     *\n\t     * @remarks Whenever InteropClient.getInfoForIntent is called this function will fire. The options argument gives you\n\t     * access to the intent name and any optional context that was passed and clientIdentity is the identity of the client\n\t     * that made the call. Ideally here you would fetch the info for the intent and return it with the shape that the\n\t     * InteropClient.getInfoForIntent call is expecting.\n\t     *\n\t     * To make this call FDC3-Compliant it would need to return an App Intent:\n\t     *\n\t     * ```js\n\t     * // {\n\t     * //     intent: { name: \"StartChat\", displayName: \"Chat\" },\n\t     * //     apps: [{ name: \"Skype\" }, { name: \"Symphony\" }, { name: \"Slack\" }]\n\t     * // }\n\t     * ```\n\t     *\n\t     * More information on the AppIntent type can be found in the [FDC3 documentation](https://fdc3.finos.org/docs/api/ref/AppIntent).\n\t     *\n\t     * @param options\n\t     * @param clientIdentity Identity of the Client making the request.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.Platform.init({\n\t     *     interopOverride: async (InteropBroker) => {\n\t     *         class Override extends InteropBroker {\n\t     *             async handleInfoForIntent(options, clientIdentity) {\n\t     *                 // Your code goes here.\n\t     *             }\n\t     *         }\n\t     *         return new Override();\n\t     *     }\n\t     * });\n\t     * ```\n\t     */\n\t    // eslint-disable-next-line class-methods-use-this\n\t    async handleInfoForIntent(options, clientIdentity // TODO(CORE-811): remove inline intersected type\n\t    ) {\n\t        const warning = (0, utils_1.generateOverrideWarning)('fdc3.findIntent', 'InteropBroker.handleInfoForIntent', clientIdentity, 'interopClient.getInfoForIntent');\n\t        console.warn(warning);\n\t        throw new Error(utils_1.BROKER_ERRORS.getInfoForIntent);\n\t    }\n\t    /**\n\t     * Responsible for returning information on which Intents are meant to handle a specific Context.\n\t     * Must be overridden.\n\t     *\n\t     * @remarks Responsible for returning information on which Intents are meant to handle a specific Context. Must be overridden.\n\t     *\n\t     * Whenever InteropClient.getInfoForIntentsByContext is called this function will fire. The context argument gives you access to the context that the client wants information on and clientIdentity is the identity of the client that made the call. Ideally here you would fetch the info for any intent that can handle and return it with the shape that the InteropClient.getInfoForIntentsByContext call is expecting.\n\t     *\n\t     * To make this call FDC3-Compliant it would need to return an array of AppIntents:\n\t     *\n\t     * ```js\n\t     * // [{\n\t     * //     intent: { name: \"StartCall\", displayName: \"Call\" },\n\t     * //     apps: [{ name: \"Skype\" }]\n\t     * // },\n\t     * // {\n\t     * //     intent: { name: \"StartChat\", displayName: \"Chat\" },\n\t     * //     apps: [{ name: \"Skype\" }, { name: \"Symphony\" }, { name: \"Slack\" }]\n\t     * // }];\n\t     * ```\n\t     *\n\t     * More information on the AppIntent type can be found in the [FDC3 documentation](https://fdc3.finos.org/docs/api/ref/AppIntent).\n\t     *\n\t     * @param context Data passed between entities and applications.\n\t     * @param clientIdentity Identity of the Client making the request.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.Platform.init({\n\t     *     interopOverride: async (InteropBroker) => {\n\t     *         class Override extends InteropBroker {\n\t     *             async handleInfoForIntentsByContext(context, clientIdentity) {\n\t     *                 // Your code goes here.\n\t     *             }\n\t     *         }\n\t     *         return new Override();\n\t     *     }\n\t     * });\n\t     * ```\n\t     */\n\t    // eslint-disable-next-line class-methods-use-this\n\t    async handleInfoForIntentsByContext(context, clientIdentity // TODO(CORE-811): remove inline intersected type\n\t    ) {\n\t        const warning = (0, utils_1.generateOverrideWarning)('fdc3.findIntentsByContext', 'InteropBroker.handleInfoForIntentsByContext', clientIdentity, 'interopClient.getInfoForIntentsByContext');\n\t        console.warn(warning);\n\t        throw new Error(utils_1.BROKER_ERRORS.getInfoForIntentsByContext);\n\t    }\n\t    /**\n\t     * Responsible for resolving an Intent based on a specific Context.\n\t     * Must be overridden.\n\t     *\n\t     * @remarks Whenever InteropClient.fireIntentForContext is called this function will fire. The contextForIntent argument\n\t     * gives you access to the context that will be resolved to an intent. It also can optionally contain any metadata relevant\n\t     * to resolving it, like a specific app the client wants the context to be handled by. The clientIdentity is the identity\n\t     * of the client that made the call.\n\t     *\n\t     * To make this call FDC3-Compliant it would need to return an IntentResolution:\n\t     *\n\t     * ```js\n\t     * // {\n\t     * //     intent: { name: \"StartChat\", displayName: \"Chat\" },\n\t     * //     apps: [{ name: \"Skype\" }, { name: \"Symphony\" }, { name: \"Slack\" }]\n\t     * // }\n\t     * ```\n\t     *\n\t     * More information on the IntentResolution type can be found in the [FDC3 documentation](https://fdc3.finos.org/docs/api/ref/Metadata#intentresolution).\n\t     *\n\t     * @param contextForIntent Data passed between entities and applications.\n\t     * @param clientIdentity Identity of the Client making the request.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.Platform.init({\n\t     *     interopOverride: async (InteropBroker) => {\n\t     *         class Override extends InteropBroker {\n\t     *             async handleFiredIntentForContext(contextForIntent, clientIdentity) {\n\t     *                 // Your code goes here.\n\t     *             }\n\t     *         }\n\t     *         return new Override();\n\t     *     }\n\t     * });\n\t     * ```\n\t     */\n\t    // eslint-disable-next-line class-methods-use-this\n\t    async handleFiredIntentForContext(contextForIntent, clientIdentity) {\n\t        const warning = (0, utils_1.generateOverrideWarning)('fdc3.raiseIntentForContext', 'InteropBroker.handleFiredIntentForContext', clientIdentity, 'interopClient.fireIntentForContext');\n\t        console.warn(warning);\n\t        throw new Error(utils_1.BROKER_ERRORS.fireIntentForContext);\n\t    }\n\t    /**\n\t     * Provides the identity of any Interop Client that disconnects from the Interop Broker. It is meant to be overriden.\n\t     * @param clientIdentity\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.Platform.init({\n\t     *     interopOverride: async (InteropBroker) => {\n\t     *         class Override extends InteropBroker {\n\t     *             async clientDisconnected(clientIdentity) {\n\t     *                 const { uuid, name } = clientIdentity;\n\t     *                 console.log(`Client with identity ${uuid}/${name} has been disconnected`);\n\t     *             }\n\t     *         }\n\t     *         return new Override();\n\t     *     }\n\t     * });\n\t     * ```\n\t     */\n\t    // eslint-disable-next-line class-methods-use-this\n\t    async clientDisconnected(clientIdentity) {\n\t        // This function is called in channel.onDisconnection.\n\t        // It is meant to be overridden to inform when an Interop Client has been disconnected.\n\t    }\n\t    /**\n\t     * Responsible for resolving an fdc3.open call.\n\t     * Must be overridden.\n\t     * @param fdc3OpenOptions fdc3.open options\n\t     * @param clientIdentity Identity of the Client making the request.\n\t     */\n\t    // eslint-disable-next-line class-methods-use-this\n\t    async fdc3HandleOpen({ app, context }, clientIdentity) {\n\t        const warning = (0, utils_1.generateOverrideWarning)('fdc3.open', 'InteropBroker.fdc3HandleOpen', clientIdentity);\n\t        console.warn(warning);\n\t        throw new Error(utils_1.BROKER_ERRORS.fdc3Open);\n\t    }\n\t    /**\n\t     * Responsible for resolving the fdc3.findInstances call.\n\t     * Must be overridden\n\t     * @param app AppIdentifier that was passed to fdc3.findInstances\n\t     * @param clientIdentity Identity of the Client making the request.\n\t     */\n\t    // eslint-disable-next-line class-methods-use-this\n\t    async fdc3HandleFindInstances(app, clientIdentity) {\n\t        const warning = (0, utils_1.generateOverrideWarning)('fdc3.open', 'InteropBroker.fdc3HandleFindInstances', clientIdentity);\n\t        console.warn(warning);\n\t        throw new Error(utils_1.BROKER_ERRORS.fdc3FindInstances);\n\t    }\n\t    /**\n\t     * Responsible for resolving the fdc3.getAppMetadata call.\n\t     * Must be overridden\n\t     * @param app AppIdentifier that was passed to fdc3.getAppMetadata\n\t     * @param clientIdentity Identity of the Client making the request.\n\t     */\n\t    // eslint-disable-next-line class-methods-use-this\n\t    async fdc3HandleGetAppMetadata(app, clientIdentity) {\n\t        const warning = (0, utils_1.generateOverrideWarning)('fdc3.getAppMetadata', 'InteropBroker.fdc3HandleGetAppMetadata', clientIdentity);\n\t        console.warn(warning);\n\t        throw new Error(utils_1.BROKER_ERRORS.fdc3GetAppMetadata);\n\t    }\n\t    /**\n\t     * This function is called by the Interop Broker whenever a Context handler would fire.\n\t     * For FDC3 2.0 you would need to override this function and add the contextMetadata as\n\t     * part of the Context object. Then would you need to call\n\t     * super.invokeContextHandler passing it this new Context object along with the clientIdentity and handlerId\n\t     * @param clientIdentity\n\t     * @param handlerId\n\t     * @param context\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.Platform.init({\n\t     *     interopOverride: async (InteropBroker) => {\n\t     *         class Override extends InteropBroker {\n\t     *             async invokeContextHandler(clientIdentity, handlerId, context) {\n\t     *                 return super.invokeContextHandler(clientIdentity, handlerId, {\n\t     *                     ...context,\n\t     *                     contextMetadata: {\n\t     *                         source: {\n\t     *                             appId: 'openfin-app',\n\t     *                             instanceId: '3D54D456D9HT0'\n\t     *                         }\n\t     *                     }\n\t     *                 });\n\t     *             }\n\t     *         }\n\t     *         return new Override();\n\t     *     }\n\t     * });\n\t     * ```\n\t     */\n\t    async invokeContextHandler(clientIdentity, handlerId, context) {\n\t        const provider = await this.getProvider();\n\t        try {\n\t            await provider.dispatch(clientIdentity, handlerId, context);\n\t        }\n\t        catch (error) {\n\t            console.error(`Error invoking context handler ${handlerId} for context type ${context.type} in client ${clientIdentity.uuid}/${clientIdentity.name}/${clientIdentity.endpointId}`, error);\n\t        }\n\t    }\n\t    /**\n\t     * This function is called by the Interop Broker whenever an Intent handler would fire.\n\t     * For FDC3 2.0 you would need to override this function and add the contextMetadata as\n\t     * part of the Context object inside the Intent object. Then would you need to call\n\t     * super.invokeIntentHandler passing it this new Intent object along with the clientIdentity and handlerId\n\t     * @param ClientIdentity\n\t     * @param handlerId\n\t     * @param context\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.Platform.init({\n\t     *     interopOverride: async (InteropBroker) => {\n\t     *         class Override extends InteropBroker {\n\t     *             async invokeIntentHandler(clientIdentity, handlerId, context) {\n\t     *                 const { context } = intent;\n\t     *                 return super.invokeIntentHandler(clientIdentity, handlerId, {\n\t     *                     ...intent,\n\t     *                     context: {\n\t     *                         ...context,\n\t     *                         contextMetadata: {\n\t     *                             source: {\n\t     *                                 appId: 'openfin-app',\n\t     *                                 instanceId: '3D54D456D9HT0'\n\t     *                             }\n\t     *                         }\n\t     *                     }\n\t     *                 });\n\t     *             }\n\t     *         }\n\t     *         return new Override();\n\t     *     }\n\t     * });\n\t     * ```\n\t     */\n\t    async invokeIntentHandler(clientIdentity, handlerId, intent) {\n\t        const provider = await this.getProvider();\n\t        await provider.dispatch(clientIdentity, handlerId, intent);\n\t    }\n\t    /**\n\t     * Responsible for resolving fdc3.getInfo for FDC3 2.0\n\t     * Would need to return the optionalFeatures and appMetadata for the {@link https://fdc3.finos.org/docs/api/ref/Metadata#implementationmetadata ImplementationMetadata}.\n\t     * Must be overridden.\n\t     * @param clientIdentity\n\t     *\n\t     */\n\t    // eslint-disable-next-line class-methods-use-this\n\t    async fdc3HandleGetInfo(payload, clientIdentity) {\n\t        const { fdc3Version } = payload;\n\t        return {\n\t            fdc3Version,\n\t            ...__classPrivateFieldGet(this, _InteropBroker_fdc3Info, \"f\"),\n\t            optionalFeatures: {\n\t                OriginatingAppMetadata: false,\n\t                UserChannelMembershipAPIs: true\n\t            },\n\t            appMetadata: {\n\t                appId: '',\n\t                instanceId: ''\n\t            }\n\t        };\n\t    }\n\t    /**\n\t     * Returns an array of info for each Interop Client connected to the Interop Broker.\n\t     *\n\t     * FDC3 2.0: Use the endpointId in the ClientInfo as the instanceId when generating\n\t     * an AppIdentifier.\n\t     *\n\t     * @remarks FDC3 2.0 Note: When needing an instanceId to generate an AppIdentifier use this call to\n\t     * get the endpointId and use it as the instanceId. In the Example below we override handleFiredIntent\n\t     * and then call super.getAllClientInfo to generate the AppIdentifier for the IntentResolution.\n\t     *\n\t     *\n\t     * @example\n\t     * ```js\n\t     * // FDC3 2.0 Example:\n\t     * fin.Platform.init({\n\t     *     interopOverride: async (InteropBroker, ...args) => {\n\t     *         class Override extends InteropBroker {\n\t     *             async handleFiredIntent(intent) {\n\t     *                 super.setIntentTarget(intent, { uuid: 'platform-uuid', name: 'intent-view' });\n\t     *                 const platform = fin.Platform.getCurrentSync();\n\t     *                 const win = fin.Window.wrapSync({ name: 'foo', uuid: 'platform-uuid' });\n\t     *                 const createdView = await platform.createView({ url: 'http://openfin.co', name: 'intent-view' }, win.identity);\n\t     *\n\t     *                 const allClientInfo = await super.getAllClientInfo();\n\t     *\n\t     *                 const infoForTarget = allClientInfo.find((clientInfo) => {\n\t     *                     return clientInfo.uuid === 'platform-uuid' && clientInfo.name === 'intent-view';\n\t     *                 });\n\t     *\n\t     *                 const source = {\n\t     *                     appId: 'intent-view',\n\t     *                     instanceId: infoForTarget.endpointId\n\t     *                 }\n\t     *\n\t     *                 return {\n\t     *                     source,\n\t     *                     intent: intent.name\n\t     *                 }\n\t     *\n\t     *             }\n\t     *         }\n\t     *         return new Override(...args);\n\t     *     }\n\t     * });\n\t     * ```\n\t     */\n\t    async getAllClientInfo() {\n\t        const provider = await this.getProvider();\n\t        return provider.getAllClientInfo();\n\t    }\n\t    /*\n\t    Snapshot APIs\n\t    */\n\t    // Used to save interop broker state in snapshots\n\t    decorateSnapshot(snapshot) {\n\t        return { ...snapshot, interopSnapshotDetails: { contextGroupStates: this.getContextGroupStates() } };\n\t    }\n\t    // Used to restore interop broker state in snapshots.\n\t    applySnapshot(snapshot, options) {\n\t        const contextGroupStates = snapshot?.interopSnapshotDetails?.contextGroupStates;\n\t        if (contextGroupStates) {\n\t            if (!options?.closeExistingWindows) {\n\t                this.updateExistingClients(contextGroupStates);\n\t            }\n\t            this.rehydrateContextGroupStates(contextGroupStates);\n\t        }\n\t    }\n\t    updateExistingClients(contextGroupStates) {\n\t        const clients = this.interopClients;\n\t        clients.forEach((subState) => {\n\t            const { clientIdentity, contextGroupId, contextHandlers } = subState;\n\t            if (contextGroupId) {\n\t                const groupContexts = contextGroupStates[contextGroupId];\n\t                for (const [, context] of Object.entries(groupContexts)) {\n\t                    contextHandlers.forEach((contextHandler) => {\n\t                        const { handlerId, contextType } = contextHandler;\n\t                        if (InteropBroker.isContextTypeCompatible(context.type, contextType)) {\n\t                            this.invokeContextHandler(clientIdentity, handlerId, context);\n\t                        }\n\t                    });\n\t                }\n\t            }\n\t        });\n\t    }\n\t    // Used to store context group state in snapshots\n\t    getContextGroupStates() {\n\t        return InteropBroker.toObject(this.contextGroupsById);\n\t    }\n\t    // Used to rehydrate the context state from a snapshot\n\t    rehydrateContextGroupStates(incomingContextGroupStates) {\n\t        const contextGroupStates = Object.entries(incomingContextGroupStates);\n\t        for (const [contextGroupId, contexts] of contextGroupStates) {\n\t            const contextObjects = Object.entries(contexts);\n\t            for (const [contextType, context] of contextObjects) {\n\t                if (this.contextGroupsById.has(contextGroupId)) {\n\t                    const currentContextGroupState = this.contextGroupsById.get(contextGroupId);\n\t                    currentContextGroupState.set(contextType, context);\n\t                }\n\t                else {\n\t                    // This logic will change when dynamic context group creation comes in.\n\t                    console.warn(`Attempting to set a context group that isn't in the context group mapping. Skipping context group rehydration for: ${contextGroupId}`);\n\t                }\n\t            }\n\t        }\n\t    }\n\t    /*\n\t    Internal Context Handler APIs\n\t    */\n\t    // Used to give context to a client that has registered their context handler\n\t    contextHandlerRegistered({ contextType, handlerId }, clientIdentity) {\n\t        const handlerInfo = { contextType, handlerId };\n\t        const clientState = this.getClientState(clientIdentity);\n\t        clientState?.contextHandlers.set(handlerId, handlerInfo);\n\t        if (clientState && clientState.contextGroupId) {\n\t            const { contextGroupId } = clientState;\n\t            const contextGroupMap = this.contextGroupsById.get(contextGroupId);\n\t            if (contextType === undefined) {\n\t                // Send this single handler all of the context, because it accepts all.\n\t                contextGroupMap.forEach((context, _) => {\n\t                    this.invokeContextHandler(clientIdentity, handlerId, context);\n\t                });\n\t            }\n\t            else if (contextGroupMap.has(contextType)) {\n\t                const contextForType = contextGroupMap.get(contextType);\n\t                if (contextForType) {\n\t                    this.invokeContextHandler(clientIdentity, handlerId, contextForType);\n\t                }\n\t            }\n\t        }\n\t    }\n\t    // eslint-disable-next-line class-methods-use-this\n\t    async intentHandlerRegistered(payload, clientIdentity) {\n\t        const { handlerId } = payload;\n\t        const clientIntentInfo = this.intentClientMap.get(clientIdentity.name);\n\t        const handlerInfo = clientIntentInfo?.get(handlerId);\n\t        if (!clientIntentInfo) {\n\t            this.intentClientMap.set(clientIdentity.name, new Map());\n\t            const newHandlerInfoMap = this.intentClientMap.get(clientIdentity.name);\n\t            if (newHandlerInfoMap) {\n\t                newHandlerInfoMap.set(handlerId, { isReady: true, pendingIntents: [], clientIdentity });\n\t            }\n\t        }\n\t        else if (!handlerInfo) {\n\t            clientIntentInfo.set(handlerId, { isReady: true, pendingIntents: [], clientIdentity });\n\t        }\n\t        else {\n\t            const { pendingIntents } = handlerInfo;\n\t            handlerInfo.clientIdentity = clientIdentity;\n\t            handlerInfo.isReady = true;\n\t            try {\n\t                if (pendingIntents.length > 0) {\n\t                    const intentToSend = pendingIntents[pendingIntents.length - 1];\n\t                    await this.invokeIntentHandler(clientIdentity, handlerId, intentToSend);\n\t                    handlerInfo.pendingIntents = [];\n\t                }\n\t            }\n\t            catch (error) {\n\t                console.error(`Error invoking intent handler: ${handlerId} for client ${clientIdentity.uuid}/${clientIdentity.name}/${clientIdentity.endpointId}`);\n\t            }\n\t        }\n\t    }\n\t    // Used to remove a context handler for a client\n\t    removeContextHandler({ handlerId }, clientIdentity) {\n\t        const clientState = this.getClientState(clientIdentity);\n\t        if (clientState) {\n\t            clientState.contextHandlers.delete(handlerId);\n\t        }\n\t    }\n\t    handleJoinSessionContextGroup({ sessionContextGroupId }, clientIdentity) {\n\t        try {\n\t            if (!sessionContextGroupId) {\n\t                throw new Error('Failed to join session context group: must specify group id.');\n\t            }\n\t            const sessionContextGroup = this.sessionContextGroupMap.get(sessionContextGroupId);\n\t            if (sessionContextGroup) {\n\t                sessionContextGroup.registerNewClient(clientIdentity);\n\t            }\n\t            else {\n\t                const newSessionContextGroupBroker = new SessionContextGroupBroker_1.default(this.channel, sessionContextGroupId);\n\t                newSessionContextGroupBroker.registerNewClient(clientIdentity);\n\t                this.sessionContextGroupMap.set(sessionContextGroupId, newSessionContextGroupBroker);\n\t            }\n\t            return { hasConflict: this.contextGroupsById.has(sessionContextGroupId) };\n\t        }\n\t        catch (error) {\n\t            throw new Error(error);\n\t        }\n\t    }\n\t    /*\n\t    Internal Utilties\n\t    */\n\t    // Getter for interop info for a client.\n\t    getClientState(id) {\n\t        return this.interopClients.get(id.endpointId);\n\t    }\n\t    // Util for getContextGroupStates. Serializes the contextGroupStates object so we can store it.\n\t    static toObject(map) {\n\t        const objectFromMap = Object.fromEntries(map);\n\t        const newObject = {};\n\t        Object.entries(objectFromMap).forEach(([contextGroupId, contextMap]) => {\n\t            const newContextObject = Object.fromEntries(contextMap);\n\t            newObject[contextGroupId] = newContextObject;\n\t        });\n\t        return newObject;\n\t    }\n\t    static checkContextIntegrity(context) {\n\t        if (!context) {\n\t            return { isValid: false, reason: 'No context supplied' };\n\t        }\n\t        if (typeof context !== 'object') {\n\t            return { isValid: false, reason: 'Context must be an Object' };\n\t        }\n\t        if (!context.type) {\n\t            return { isValid: false, reason: 'Context must have a type property' };\n\t        }\n\t        if (context.id && typeof context.id !== 'object') {\n\t            return {\n\t                isValid: false,\n\t                reason: 'Context id must be an Object populated with key-value identifiers (if set)'\n\t            };\n\t        }\n\t        if (context.id) {\n\t            const { id } = context;\n\t            const keys = Object.keys(id);\n\t            let foundBadIdentifier = false;\n\t            if (!keys.length) {\n\t                return { isValid: false, reason: 'Context id must have at least one key-value identifier' };\n\t            }\n\t            keys.forEach((key) => {\n\t                if (typeof key !== 'string' || typeof id[key] !== 'string') {\n\t                    foundBadIdentifier = true;\n\t                }\n\t            });\n\t            if (foundBadIdentifier) {\n\t                return { isValid: false, reason: 'Context id key-value identifiers must be of type string' };\n\t            }\n\t        }\n\t        if (context.name && typeof context.name !== 'string') {\n\t            return { isValid: false, reason: 'Context name must be of string type (if set)' };\n\t        }\n\t        return { isValid: true };\n\t    }\n\t    // Util to check a client identity.\n\t    static hasEndpointId(target) {\n\t        return target.endpointId !== undefined;\n\t    }\n\t    // Util to check if we should send a context to a handler.\n\t    static isContextTypeCompatible(contextType, registeredContextType) {\n\t        return typeof registeredContextType === 'undefined' || contextType === registeredContextType;\n\t    }\n\t    // Setup function for state mapping\n\t    setContextGroupMap() {\n\t        // This way, if a user overrides this.getContextGroups, it's reflected in the contextGroupMapping.\n\t        for (const contextGroupInfo of this.getContextGroups()) {\n\t            this.contextGroupsById.set(contextGroupInfo.id, new Map());\n\t        }\n\t    }\n\t    async setCurrentContextGroupInClientOptions(clientIdentity, contextGroupId) {\n\t        try {\n\t            const entityInfo = await this.fin.System.getEntityInfo(clientIdentity.uuid, clientIdentity.name);\n\t            let entity;\n\t            if (entityInfo.entityType === 'view') {\n\t                entity = await this.fin.View.wrap(clientIdentity);\n\t            }\n\t            else if (entityInfo.entityType === 'window') {\n\t                entity = await this.fin.Window.wrap(clientIdentity);\n\t            }\n\t            if (entity) {\n\t                await entity.updateOptions({\n\t                    interop: {\n\t                        currentContextGroup: contextGroupId\n\t                    }\n\t                });\n\t            }\n\t        }\n\t        catch (error) {\n\t            //  May file in interop\n\t        }\n\t    }\n\t    async setupChannelProvider() {\n\t        try {\n\t            const channel = await this.getProvider();\n\t            this.channel = channel;\n\t            this.wireChannel(channel);\n\t        }\n\t        catch (error) {\n\t            throw new Error(`Error setting up Interop Broker Channel Provider: ${error}`);\n\t        }\n\t    }\n\t    // Setup Channel Connection Logic\n\t    wireChannel(channel) {\n\t        channel.onConnection(async (clientIdentity, // TODO(CORE-811): remove inline intersected type\n\t        payload) => {\n\t            if (!(await this.isConnectionAuthorized(clientIdentity, payload))) {\n\t                throw new Error(`Connection not authorized for ${clientIdentity.uuid}, ${clientIdentity.name}`);\n\t            }\n\t            if (!clientIdentity.endpointId) {\n\t                throw new Error('Version too old to be compatible with Interop. Please upgrade your runtime to a more recent version.');\n\t            }\n\t            const clientSubscriptionState = {\n\t                contextGroupId: undefined,\n\t                contextHandlers: new Map(),\n\t                clientIdentity\n\t            };\n\t            // Only allow the client to join a contextGroup that actually exists.\n\t            if (payload?.currentContextGroup && this.contextGroupsById.has(payload.currentContextGroup)) {\n\t                clientSubscriptionState.contextGroupId = payload?.currentContextGroup;\n\t            }\n\t            this.interopClients.set(clientIdentity.endpointId, clientSubscriptionState);\n\t        });\n\t        channel.onDisconnection((clientIdentity) => {\n\t            this.interopClients.delete(clientIdentity.endpointId);\n\t            const targetInfo = this.intentClientMap.get(clientIdentity.name);\n\t            if (targetInfo && clientIdentity.uuid === this.fin.me.uuid) {\n\t                targetInfo.forEach((handler) => {\n\t                    handler.isReady = false;\n\t                });\n\t            }\n\t            this.sessionContextGroupMap.forEach((sessionContextGroup) => {\n\t                sessionContextGroup.onDisconnection(clientIdentity);\n\t            });\n\t            this.clientDisconnected(clientIdentity);\n\t        });\n\t        channel.beforeAction(async (action, payload, clientIdentity) => {\n\t            if (!(await this.isActionAuthorized(action, payload, clientIdentity))) {\n\t                throw new Error(`Action (${action}) not authorized for ${clientIdentity.uuid}, ${clientIdentity.name}`);\n\t            }\n\t            if (this.logging?.beforeAction?.enabled) {\n\t                console.log(action, payload, clientIdentity);\n\t            }\n\t        });\n\t        channel.afterAction((action, payload, clientIdentity) => {\n\t            if (this.logging?.afterAction?.enabled) {\n\t                console.log(action, payload, clientIdentity);\n\t            }\n\t        });\n\t        // Client functions\n\t        channel.register('setContext', this.setContext.bind(this));\n\t        channel.register('fireIntent', this.handleFiredIntent.bind(this));\n\t        channel.register('getCurrentContext', this.getCurrentContext.bind(this));\n\t        channel.register('getInfoForIntent', this.handleInfoForIntent.bind(this));\n\t        channel.register('getInfoForIntentsByContext', this.handleInfoForIntentsByContext.bind(this));\n\t        channel.register('fireIntentForContext', this.handleFiredIntentForContext.bind(this));\n\t        // Platform window functions\n\t        channel.register('getContextGroups', this.getContextGroups.bind(this));\n\t        channel.register('joinContextGroup', this.joinContextGroup.bind(this));\n\t        channel.register('removeFromContextGroup', this.removeFromContextGroup.bind(this));\n\t        channel.register('getAllClientsInContextGroup', this.getAllClientsInContextGroup.bind(this));\n\t        channel.register('getInfoForContextGroup', this.getInfoForContextGroup.bind(this));\n\t        // Internal methods\n\t        channel.register('contextHandlerRegistered', this.contextHandlerRegistered.bind(this));\n\t        channel.register('intentHandlerRegistered', this.intentHandlerRegistered.bind(this));\n\t        channel.register('removeContextHandler', this.removeContextHandler.bind(this));\n\t        channel.register('sessionContextGroup:createIfNeeded', this.handleJoinSessionContextGroup.bind(this));\n\t        // fdc3 only methods\n\t        channel.register('fdc3Open', this.fdc3HandleOpen.bind(this));\n\t        channel.register('fdc3v2FindIntentsByContext', this.handleInfoForIntentsByContext.bind(this));\n\t        channel.register('fdc3FindInstances', this.fdc3HandleFindInstances.bind(this));\n\t        channel.register('fdc3GetAppMetadata', this.fdc3HandleGetAppMetadata.bind(this));\n\t        channel.register('fdc3v2GetInfo', async (payload, clientIdentity) => {\n\t            return this.fdc3HandleGetInfo.bind(this)(payload, clientIdentity);\n\t        });\n\t        channel.register('createPrivateChannelProvider', async (payload) => {\n\t            const { channelId } = payload;\n\t            const channelProvider = await this.fin.InterApplicationBus.Channel.create(channelId);\n\t            PrivateChannelProvider_1.PrivateChannelProvider.init(channelProvider, channelId);\n\t        });\n\t    }\n\t    /**\n\t     * Can be used to completely prevent a connection. Return false to prevent connections. Allows all connections by default.\n\t     * @param _id the identity tryinc to connect\n\t     * @param _connectionPayload optional payload to use in custom implementations, will be undefined by default\n\t     */\n\t    isConnectionAuthorized(_id, _connectionPayload) {\n\t        this.wire.sendAction('interop-broker-is-connection-authorized').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        return Promise.resolve(true);\n\t    }\n\t    /**\n\t     * Called before every action to check if this entity should be allowed to take the action.\n\t     * Return false to prevent the action\n\t     * @param _action the string action to authorize in camel case\n\t     * @param _payload the data being sent for this action\n\t     * @param _identity the connection attempting to dispatch this action\n\t     */\n\t    isActionAuthorized(_action, _payload, _identity) {\n\t        this.wire.sendAction('interop-broker-is-action-authorized').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        return Promise.resolve(true);\n\t    }\n\t};\n\tInteropBroker.InteropBroker = InteropBroker$1;\n\t_InteropBroker_fdc3Info = new WeakMap(), _InteropBroker_contextGroups = new WeakMap(), _InteropBroker_providerPromise = new WeakMap();\n\treturn InteropBroker;\n}\n\nvar InteropClient = {};\n\nvar SessionContextGroupClient$1 = {};\n\nvar __classPrivateFieldSet$2 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar __classPrivateFieldGet$2 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar _SessionContextGroupClient_clientPromise;\nObject.defineProperty(SessionContextGroupClient$1, \"__esModule\", { value: true });\nconst base_1$2 = base;\nconst utils_1$2 = utils$3;\nclass SessionContextGroupClient extends base_1$2.Base {\n    constructor(wire, client, id) {\n        super(wire);\n        _SessionContextGroupClient_clientPromise.set(this, void 0);\n        this.id = id;\n        __classPrivateFieldSet$2(this, _SessionContextGroupClient_clientPromise, client, \"f\");\n    }\n    /**\n     * Sets a context for the session context group.\n     * @param context - New context to set.\n     *\n     * @tutorial interop.setContext\n     */\n    async setContext(context) {\n        this.wire.sendAction('interop-session-context-group-set-context').catch((e) => {\n            // don't expose, analytics-only call\n        });\n        const client = await __classPrivateFieldGet$2(this, _SessionContextGroupClient_clientPromise, \"f\");\n        return client.dispatch(`sessionContextGroup:setContext-${this.id}`, {\n            sessionContextGroupId: this.id,\n            context\n        });\n    }\n    async getCurrentContext(type) {\n        this.wire.sendAction('interop-session-context-group-get-context').catch((e) => {\n            // don't expose, analytics-only call\n        });\n        const client = await __classPrivateFieldGet$2(this, _SessionContextGroupClient_clientPromise, \"f\");\n        return client.dispatch(`sessionContextGroup:getContext-${this.id}`, {\n            sessionContextGroupId: this.id,\n            type\n        });\n    }\n    async addContextHandler(contextHandler, contextType) {\n        this.wire.sendAction('interop-session-context-group-add-handler').catch((e) => {\n            // don't expose, analytics-only call\n        });\n        if (typeof contextHandler !== 'function') {\n            throw new Error(\"Non-function argument passed to the first parameter 'handler'. Be aware that the argument order does not match the FDC3 standard.\");\n        }\n        const client = await __classPrivateFieldGet$2(this, _SessionContextGroupClient_clientPromise, \"f\");\n        let handlerId;\n        if (contextType) {\n            handlerId = `sessionContextHandler:invoke-${this.id}-${contextType}-${(0, utils_1$2.generateId)()}`;\n        }\n        else {\n            handlerId = `sessionContextHandler:invoke-${this.id}`;\n        }\n        client.register(handlerId, (0, utils_1$2.wrapContextHandler)(contextHandler, handlerId));\n        await client.dispatch(`sessionContextGroup:handlerAdded-${this.id}`, { handlerId, contextType });\n        return { unsubscribe: await this.createUnsubscribeCb(handlerId) };\n    }\n    async createUnsubscribeCb(handlerId) {\n        const client = await __classPrivateFieldGet$2(this, _SessionContextGroupClient_clientPromise, \"f\");\n        return async () => {\n            client.remove(handlerId);\n            await client.dispatch(`sessionContextGroup:handlerRemoved-${this.id}`, { handlerId });\n        };\n    }\n    getUserInstance() {\n        return {\n            id: this.id,\n            setContext: (0, utils_1$2.wrapInTryCatch)(this.setContext.bind(this), 'Failed to set context: '),\n            getCurrentContext: (0, utils_1$2.wrapInTryCatch)(this.getCurrentContext.bind(this), 'Failed to get context: '),\n            addContextHandler: (0, utils_1$2.wrapInTryCatch)(this.addContextHandler.bind(this), 'Failed to add context handler: ')\n        };\n    }\n}\nSessionContextGroupClient$1.default = SessionContextGroupClient;\n_SessionContextGroupClient_clientPromise = new WeakMap();\n\nvar fdc31_2 = {};\n\nvar fdc3Common = {};\n\nvar utils$2 = {};\n\nvar PrivateChannelClient$1 = {};\n\nvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (commonjsGlobal && commonjsGlobal.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (commonjsGlobal && commonjsGlobal.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nObject.defineProperty(PrivateChannelClient$1, \"__esModule\", { value: true });\nPrivateChannelClient$1.PrivateChannelClient = void 0;\nconst utils$1 = __importStar(utils$3);\nclass PrivateChannelClient {\n    constructor(client, id) {\n        this.id = id;\n        this.client = client;\n        this.listeners = new Map();\n    }\n    async broadcast(context) {\n        return this.client.dispatch('broadcast', { context });\n    }\n    async getCurrentContext(contextType) {\n        return this.client.dispatch('getCurrentContext', { contextType });\n    }\n    async addContextListener(contextType, handler) {\n        if (typeof handler !== 'function') {\n            throw new Error(\"Non-function argument passed to the second parameter 'handler'. Be aware that the argument order does not match the FDC3 standard.\");\n        }\n        let handlerId;\n        if (contextType) {\n            handlerId = `contextHandler:invoke-${this.id}-${contextType}-${utils$1.generateId()}`;\n        }\n        else {\n            handlerId = `contextHandler:invoke-${this.id}-${utils$1.generateId()}`;\n        }\n        this.client.register(handlerId, utils$1.wrapContextHandler(handler, handlerId));\n        const listener = { unsubscribe: await this.createContextUnsubscribeCb(handlerId) };\n        this.listeners.set(handlerId, listener);\n        await this.client.dispatch(`contextHandlerAdded`, { handlerId, contextType });\n        return listener;\n    }\n    createNonStandardUnsubscribeCb(handlerId) {\n        return async () => {\n            this.client.remove(handlerId);\n            this.listeners.delete(handlerId);\n            await this.client.dispatch('nonStandardHandlerRemoved', { handlerId });\n        };\n    }\n    createContextUnsubscribeCb(handlerId) {\n        return async () => {\n            this.client.remove(handlerId);\n            this.listeners.delete(handlerId);\n            await this.client.dispatch('contextHandlerRemoved', { handlerId });\n        };\n    }\n    onAddContextListener(handler) {\n        const handlerId = `onContextHandlerAdded:invoke-${this.id}-${utils$1.generateId()}`;\n        this.client.register(handlerId, handler);\n        const listener = { unsubscribe: this.createNonStandardUnsubscribeCb(handlerId) };\n        this.listeners.set(handlerId, listener);\n        this.client.dispatch(`onAddContextHandlerAdded`, { handlerId });\n        return listener;\n    }\n    onDisconnect(handler) {\n        const handlerId = `onDisconnect:invoke-${this.id}-${utils$1.generateId()}`;\n        this.client.register(handlerId, handler);\n        const listener = { unsubscribe: this.createNonStandardUnsubscribeCb(handlerId) };\n        this.listeners.set(handlerId, listener);\n        this.client.dispatch(`onDisconnectHandlerAdded`, { handlerId });\n        return listener;\n    }\n    onUnsubscribe(handler) {\n        const handlerId = `onUnsubscribe:invoke-${this.id}-${utils$1.generateId()}`;\n        this.client.register(handlerId, handler);\n        const listener = { unsubscribe: this.createNonStandardUnsubscribeCb(handlerId) };\n        this.listeners.set(handlerId, listener);\n        this.client.dispatch(`onUnsubscribeHandlerAdded`, { handlerId });\n        return listener;\n    }\n    async cleanUpAllSubs() {\n        const listenerUnsubscribers = Array.from(this.listeners.keys());\n        listenerUnsubscribers.forEach((handlerId) => {\n            this.client.remove(handlerId);\n            this.listeners.delete(handlerId);\n        });\n    }\n    async disconnect() {\n        try {\n            await this.client.dispatch('clientDisconnecting');\n            await this.cleanUpAllSubs();\n            await this.client.disconnect();\n        }\n        catch (error) {\n            throw new Error(error.message);\n        }\n    }\n}\nPrivateChannelClient$1.PrivateChannelClient = PrivateChannelClient;\n\n(function (exports) {\n\tvar __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {\n\t    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n\t};\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\texports.getIntentResolution = exports.isChannel = exports.isContext = exports.connectPrivateChannel = exports.buildAppChannelObject = exports.buildPrivateChannelObject = exports.ChannelError = exports.ResultError = exports.UnsupportedChannelApiError = exports.getUnsupportedChannelApis = void 0;\n\tconst utils_1 = utils$3;\n\tconst PrivateChannelClient_1 = PrivateChannelClient$1;\n\tconst isEqual_1 = __importDefault(require$$3);\n\tconst getUnsupportedChannelApis = (channelType) => {\n\t    return {\n\t        addContextListener: () => {\n\t            throw new UnsupportedChannelApiError('Channel.addContextListener', channelType);\n\t        },\n\t        broadcast: () => {\n\t            throw new UnsupportedChannelApiError('Channel.broadcast', channelType);\n\t        },\n\t        getCurrentContext: () => {\n\t            throw new UnsupportedChannelApiError('Channel.getCurrentContext', channelType);\n\t        }\n\t    };\n\t};\n\texports.getUnsupportedChannelApis = getUnsupportedChannelApis;\n\tclass UnsupportedChannelApiError extends Error {\n\t    constructor(apiName, channelType = 'System') {\n\t        super(apiName);\n\t        this.message = `Calling ${apiName} on an instance of a ${channelType} Channel returned by fdc3.get${channelType}Channels is not supported. If you would like to use a ${channelType} Channel, please use fdc3.joinChannel, fdc3.addContextListener, and fdc3.broadcast instead.`;\n\t    }\n\t}\n\texports.UnsupportedChannelApiError = UnsupportedChannelApiError;\n\tvar ResultError;\n\t(function (ResultError) {\n\t    /** Returned if the `IntentHandler` exited without returning a Promise or that\n\t     *  Promise was not resolved with a Context or Channel object.\n\t     */\n\t    ResultError[\"NoResultReturned\"] = \"NoResultReturned\";\n\t    /** Returned if the `IntentHandler` function processing the raised intent\n\t     *  throws an error or rejects the Promise it returned.\n\t     */\n\t    ResultError[\"IntentHandlerRejected\"] = \"IntentHandlerRejected\";\n\t})(ResultError = exports.ResultError || (exports.ResultError = {}));\n\t(function (ChannelError) {\n\t    /** Returned if the specified channel is not found when attempting to join a\n\t     *  channel via the `joinUserChannel` function of the DesktopAgent (`fdc3`).\n\t     */\n\t    ChannelError[\"NoChannelFound\"] = \"NoChannelFound\";\n\t    /** SHOULD be returned when a request to join a user channel or to a retrieve\n\t     *  a Channel object via the `joinUserChannel` or `getOrCreateChannel` methods\n\t     *  of the DesktopAgent (`fdc3`) object is denied.\n\t     */\n\t    ChannelError[\"AccessDenied\"] = \"AccessDenied\";\n\t    /** SHOULD be returned when a channel cannot be created or retrieved via the\n\t     *  `getOrCreateChannel` method of the DesktopAgent (`fdc3`).\n\t     */\n\t    ChannelError[\"CreationFailed\"] = \"CreationFailed\";\n\t})(exports.ChannelError || (exports.ChannelError = {}));\n\tconst buildPrivateChannelObject = (privateChannelClient) => {\n\t    let clientDisconnected = false;\n\t    const checkIfClientDisconnected = () => {\n\t        if (clientDisconnected) {\n\t            throw new Error('Private Channel Client has been disconnected from the Private Channel');\n\t        }\n\t    };\n\t    return {\n\t        id: privateChannelClient.id,\n\t        type: 'private',\n\t        broadcast: async (context) => {\n\t            checkIfClientDisconnected();\n\t            return privateChannelClient.broadcast(context);\n\t        },\n\t        getCurrentContext: async (contextType) => {\n\t            checkIfClientDisconnected();\n\t            return privateChannelClient.getCurrentContext(contextType);\n\t        },\n\t        // @ts-expect-error TODO [CORE-1524]\n\t        addContextListener: async (contextType, handler) => {\n\t            checkIfClientDisconnected();\n\t            let handlerInUse = handler;\n\t            let contextTypeInUse = contextType;\n\t            if (typeof contextType === 'function') {\n\t                console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');\n\t                handlerInUse = contextType;\n\t                contextTypeInUse = null;\n\t            }\n\t            const listener = privateChannelClient.addContextListener(contextTypeInUse, handlerInUse);\n\t            return listener;\n\t        },\n\t        onAddContextListener: (handler) => {\n\t            checkIfClientDisconnected();\n\t            return privateChannelClient.onAddContextListener(handler);\n\t        },\n\t        disconnect: async () => {\n\t            checkIfClientDisconnected();\n\t            clientDisconnected = true;\n\t            return privateChannelClient.disconnect();\n\t        },\n\t        onDisconnect: (handler) => {\n\t            checkIfClientDisconnected();\n\t            return privateChannelClient.onDisconnect(handler);\n\t        },\n\t        onUnsubscribe: (handler) => {\n\t            checkIfClientDisconnected();\n\t            return privateChannelClient.onUnsubscribe(handler);\n\t        }\n\t    };\n\t};\n\texports.buildPrivateChannelObject = buildPrivateChannelObject;\n\tconst buildAppChannelObject = (sessionContextGroup) => {\n\t    return {\n\t        id: sessionContextGroup.id,\n\t        type: 'app',\n\t        broadcast: sessionContextGroup.setContext,\n\t        getCurrentContext: async (contextType) => {\n\t            const context = await sessionContextGroup.getCurrentContext(contextType);\n\t            return context === undefined ? null : context;\n\t        },\n\t        // @ts-expect-error TODO [CORE-1524]\n\t        addContextListener: (contextType, handler) => {\n\t            let realHandler;\n\t            let realType;\n\t            if (typeof contextType === 'function') {\n\t                console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');\n\t                realHandler = contextType;\n\t            }\n\t            else {\n\t                realHandler = handler;\n\t                if (typeof contextType === 'string') {\n\t                    realType = contextType;\n\t                }\n\t            }\n\t            const listener = (async () => {\n\t                let first = true;\n\t                const currentContext = await sessionContextGroup.getCurrentContext(realType);\n\t                const wrappedHandler = (context, contextMetadata) => {\n\t                    if (first) {\n\t                        first = false;\n\t                        if ((0, isEqual_1.default)(currentContext, context)) {\n\t                            return;\n\t                        }\n\t                    }\n\t                    // eslint-disable-next-line consistent-return\n\t                    return realHandler(context, contextMetadata);\n\t                };\n\t                return sessionContextGroup.addContextHandler(wrappedHandler, realType);\n\t            })();\n\t            return {\n\t                ...listener,\n\t                unsubscribe: () => listener.then((l) => l.unsubscribe())\n\t            };\n\t        }\n\t    };\n\t};\n\texports.buildAppChannelObject = buildAppChannelObject;\n\tconst connectPrivateChannel = async (channelId) => {\n\t    try {\n\t        const channelClient = await fin.InterApplicationBus.Channel.connect(channelId);\n\t        const privateChannelClient = new PrivateChannelClient_1.PrivateChannelClient(channelClient, channelId);\n\t        return (0, exports.buildPrivateChannelObject)(privateChannelClient);\n\t    }\n\t    catch (error) {\n\t        throw new Error(`Private Channel with id: ${channelId} doesn't exist`);\n\t    }\n\t};\n\texports.connectPrivateChannel = connectPrivateChannel;\n\tconst isContext = (context) => {\n\t    if (context && typeof context === 'object' && 'type' in context) {\n\t        const { type } = context;\n\t        return typeof type === 'string';\n\t    }\n\t    return false;\n\t};\n\texports.isContext = isContext;\n\tconst isChannel = (channel) => {\n\t    if (channel && typeof channel === 'object' && 'type' in channel && 'id' in channel) {\n\t        const { type, id } = channel;\n\t        return typeof type === 'string' && typeof id === 'string' && (type === 'app' || type === 'private');\n\t    }\n\t    return false;\n\t};\n\texports.isChannel = isChannel;\n\tconst getIntentResolution = async (interopModule, context, app, intent) => {\n\t    // Generate an ID to make a session context group with. We will pass that ID to the Broker.\n\t    // The broker will then setContext on that session context group later with our Intent Result,\n\t    const guid = (0, utils_1.generateId)(); // TODO make this undefined in web\n\t    // Promise we'll use in getResult\n\t    const getResultPromise = new Promise((resolve, reject) => {\n\t        fin.InterApplicationBus.subscribe({ uuid: '*' }, guid, (intentResult) => {\n\t            resolve(intentResult);\n\t        }).catch(() => reject(new Error('getResult is not supported in this environment')));\n\t    });\n\t    // Adding the intentResolutionResultId to the intentObj. Because fireIntent only accepts a single arg, we have to slap it in here.\n\t    const metadata = app ? { target: app, intentResolutionResultId: guid } : { intentResolutionResultId: guid };\n\t    const intentObj = intent ? { name: intent, context, metadata } : { ...context, metadata };\n\t    // Set up the getResult call.\n\t    const getResult = async () => {\n\t        let intentResult = await getResultPromise;\n\t        if (!intentResult || typeof intentResult !== 'object') {\n\t            throw new Error(ResultError.NoResultReturned);\n\t        }\n\t        const { error } = intentResult;\n\t        if (error) {\n\t            throw new Error(ResultError.IntentHandlerRejected);\n\t        }\n\t        if ((0, exports.isChannel)(intentResult)) {\n\t            const { id, type } = intentResult;\n\t            switch (type) {\n\t                case 'private': {\n\t                    intentResult = await (0, exports.connectPrivateChannel)(id);\n\t                    break;\n\t                }\n\t                case 'app': {\n\t                    const sessionContextGroup = await interopModule.joinSessionContextGroup(id);\n\t                    intentResult = (0, exports.buildAppChannelObject)(sessionContextGroup);\n\t                    break;\n\t                }\n\t            }\n\t        }\n\t        else if (!(0, exports.isContext)(intentResult)) {\n\t            throw new Error(ResultError.NoResultReturned);\n\t        }\n\t        return intentResult;\n\t    };\n\t    // Finally fire the intent.\n\t    const intentResolutionInfoFromBroker = intent\n\t        ? await interopModule.fireIntent(intentObj)\n\t        : await interopModule.fireIntentForContext(intentObj);\n\t    if (typeof intentResolutionInfoFromBroker !== 'object') {\n\t        return {\n\t            source: {\n\t                appId: '',\n\t                instanceId: ''\n\t            },\n\t            intent: '',\n\t            version: '2.0',\n\t            getResult\n\t        };\n\t    }\n\t    return { ...intentResolutionInfoFromBroker, getResult };\n\t};\n\texports.getIntentResolution = getIntentResolution; \n} (utils$2));\n\nvar hasRequiredFdc3Common;\n\nfunction requireFdc3Common () {\n\tif (hasRequiredFdc3Common) return fdc3Common;\n\thasRequiredFdc3Common = 1;\n\tvar __classPrivateFieldGet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n\t    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n\t    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n\t    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n\t};\n\tvar __classPrivateFieldSet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n\t    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n\t    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n\t    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n\t    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n\t};\n\tvar __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {\n\t    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n\t};\n\tvar _FDC3ModuleBase_producer;\n\tObject.defineProperty(fdc3Common, \"__esModule\", { value: true });\n\tfdc3Common.FDC3ModuleBase = void 0;\n\tconst utils_1 = utils$2;\n\tconst utils_2 = utils$3;\n\tconst InteropClient_1 = requireInteropClient();\n\tconst isEqual_1 = __importDefault(require$$3);\n\tclass FDC3ModuleBase {\n\t    get client() {\n\t        return __classPrivateFieldGet(this, _FDC3ModuleBase_producer, \"f\").call(this);\n\t    }\n\t    get fin() {\n\t        return this.wire.getFin();\n\t    }\n\t    // eslint-disable-next-line no-useless-constructor\n\t    constructor(producer, wire) {\n\t        this.wire = wire;\n\t        _FDC3ModuleBase_producer.set(this, void 0);\n\t        __classPrivateFieldSet(this, _FDC3ModuleBase_producer, producer, \"f\");\n\t    }\n\t    /**\n\t     * Broadcasts a context for the channel of the current entity.\n\t     * @param context - New context to set.\n\t     *\n\t     * @tutorial fdc3.broadcast\n\t     * @static\n\t     */\n\t    async broadcast(context) {\n\t        this.wire.sendAction('fdc3-broadcast').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return this.client.setContext(context);\n\t    }\n\t    /**\n\t     * Launches an app with target information, which can either be a string or an AppMetadata object.\n\t     * @param app\n\t     * @param context\n\t     *\n\t     * @tutorial fdc3.open\n\t     */\n\t    async _open(app, context) {\n\t        this.wire.sendAction('fdc3-open').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        try {\n\t            return await InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'fdc3Open', { app, context });\n\t        }\n\t        catch (error) {\n\t            const errorToThrow = error.message === utils_2.BROKER_ERRORS.fdc3Open ? 'ResolverUnavailable' : error.message;\n\t            throw new Error(errorToThrow);\n\t        }\n\t    }\n\t    async _getChannels() {\n\t        const channels = await this.client.getContextGroups();\n\t        // fdc3 implementation of getSystemChannels returns an array of channels, have to decorate over\n\t        // this so people know that these APIs are not supported\n\t        return channels.map((channel) => {\n\t            return { ...channel, type: 'system', ...(0, utils_1.getUnsupportedChannelApis)() };\n\t        });\n\t    }\n\t    /**\n\t     * Returns a Channel object for the specified channel, creating it as an App Channel if it does not exist.\n\t     * @param channelId\n\t     *\n\t     * @tutorial fdc3.getOrCreateChannel\n\t     */\n\t    async getOrCreateChannel(channelId) {\n\t        this.wire.sendAction('fdc3-get-or-create-channel').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const systemChannels = await this._getChannels();\n\t        const userChannel = systemChannels.find((channel) => channel.id === channelId);\n\t        if (userChannel) {\n\t            return { ...userChannel, type: 'system', ...(0, utils_1.getUnsupportedChannelApis)() };\n\t        }\n\t        try {\n\t            const sessionContextGroup = await this.client.joinSessionContextGroup(channelId);\n\t            return (0, utils_1.buildAppChannelObject)(sessionContextGroup);\n\t        }\n\t        catch (error) {\n\t            console.error(error.message);\n\t            throw new Error(utils_1.ChannelError.CreationFailed);\n\t        }\n\t    }\n\t    /**\n\t     * Returns the Interop-Broker-defined context groups available for an entity to join.\n\t     *\n\t     * @tutorial fdc3.getSystemChannels\n\t     * @static\n\t     */\n\t    async getSystemChannels() {\n\t        this.wire.sendAction('fdc3-get-system-channels').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return this._getChannels();\n\t    }\n\t    /**\n\t     * Join all Interop Clients at the given identity to context group `contextGroupId`.\n\t     * If no target is specified, it adds the sender to the context group.\n\t     * Because multiple Channel connections/Interop Clients can potentially exist at a `uuid`/`name` combo, we currently join all Channel connections/Interop Clients at the given identity to the context group.\n\t     * If an `endpointId` is provided (which is unlikely, unless the call is coming from an external adapter), then we only join that single connection to the context group.\n\t     * For all intents and purposes, there will only be 1 connection present in Platform and Browser implementations, so this point is more-or-less moot.\n\t     * @param channelId - Id of the context group.\n\t     *\n\t     * @tutorial fdc3.joinChannel\n\t     * @static\n\t     */\n\t    async joinChannel(channelId) {\n\t        this.wire.sendAction('fdc3-join-channel').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        try {\n\t            return await this.client.joinContextGroup(channelId);\n\t        }\n\t        catch (error) {\n\t            if (error.message === utils_2.BROKER_ERRORS.joinSessionContextGroupWithJoinContextGroup) {\n\t                console.error('The Channel you have tried to join is an App Channel. Custom Channels can only be defined by the Interop Broker through code or manifest configuration. Please use getOrCreateChannel.');\n\t            }\n\t            else {\n\t                console.error(error.message);\n\t            }\n\t            if (error.message.startsWith('Attempting to join a context group that does not exist')) {\n\t                throw new Error(utils_1.ChannelError.NoChannelFound);\n\t            }\n\t            throw new Error(utils_1.ChannelError.AccessDenied);\n\t        }\n\t    }\n\t    /**\n\t     * Returns the Channel that the entity is subscribed to. Returns null if not joined to a channel.\n\t     *\n\t     * @tutorial fdc3.getCurrentChannel\n\t     */\n\t    async getCurrentChannel() {\n\t        this.wire.sendAction('fdc3-get-current-channel').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const currentContextGroupInfo = await this.getCurrentContextGroupInfo();\n\t        if (!currentContextGroupInfo) {\n\t            return null;\n\t        }\n\t        return this.buildChannelObject(currentContextGroupInfo);\n\t    }\n\t    /**\n\t     * Removes the specified target from a context group.\n\t     * If no target is specified, it removes the sender from their context group.\n\t     *\n\t     * @tutorial fdc3.leaveCurrentChannel\n\t     * @static\n\t     */\n\t    async leaveCurrentChannel() {\n\t        this.wire.sendAction('fdc3-leave-current-channel').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return this.client.removeFromContextGroup();\n\t    }\n\t    // utils\n\t    // eslint-disable-next-line class-methods-use-this\n\t    async getCurrentContextGroupInfo() {\n\t        const contextGroups = await this.client.getContextGroups();\n\t        const clientsInCtxGroupsPromise = contextGroups.map(async (ctxGroup) => {\n\t            return this.client.getAllClientsInContextGroup(ctxGroup.id);\n\t        });\n\t        const clientsInCtxGroups = await Promise.all(clientsInCtxGroupsPromise);\n\t        const clientIdx = clientsInCtxGroups.findIndex((clientIdentityArr) => {\n\t            return clientIdentityArr.some((clientIdentity) => {\n\t                const { uuid, name } = clientIdentity;\n\t                return this.wire.me.uuid === uuid && this.wire.me.name === name;\n\t            });\n\t        });\n\t        return contextGroups[clientIdx];\n\t    }\n\t    async buildChannelObject(currentContextGroupInfo) {\n\t        // @ts-expect-error\n\t        return {\n\t            ...currentContextGroupInfo,\n\t            type: 'system',\n\t            addContextListener: (...[contextType, handler]) => {\n\t                let realHandler;\n\t                let realType;\n\t                if (typeof contextType === 'function') {\n\t                    console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');\n\t                    realHandler = contextType;\n\t                }\n\t                else {\n\t                    realHandler = handler;\n\t                    if (typeof contextType === 'string') {\n\t                        realType = contextType;\n\t                    }\n\t                }\n\t                const listener = (async () => {\n\t                    let first = true;\n\t                    const currentContext = await this.client.getCurrentContext(realType);\n\t                    const wrappedHandler = (context, contextMetadata) => {\n\t                        if (first) {\n\t                            first = false;\n\t                            if ((0, isEqual_1.default)(currentContext, context)) {\n\t                                return;\n\t                            }\n\t                        }\n\t                        // eslint-disable-next-line consistent-return\n\t                        return realHandler(context, contextMetadata);\n\t                    };\n\t                    return this.client.addContextHandler(wrappedHandler, realType);\n\t                })();\n\t                // @ts-expect-error TODO [CORE-1524]\n\t                return {\n\t                    ...listener,\n\t                    unsubscribe: () => listener.then((l) => l.unsubscribe())\n\t                };\n\t            },\n\t            broadcast: this.broadcast.bind(this),\n\t            // @ts-expect-error Typescript fails to infer the returntype is a Promise\n\t            getCurrentContext: async (contextType) => {\n\t                const context = await this.client.getCurrentContext(contextType);\n\t                // @ts-expect-error Typescript fails to infer the returntype is a Promise\n\t                return context === undefined ? null : context;\n\t            }\n\t        };\n\t    }\n\t}\n\tfdc3Common.FDC3ModuleBase = FDC3ModuleBase;\n\t_FDC3ModuleBase_producer = new WeakMap();\n\treturn fdc3Common;\n}\n\nvar hasRequiredFdc31_2;\n\nfunction requireFdc31_2 () {\n\tif (hasRequiredFdc31_2) return fdc31_2;\n\thasRequiredFdc31_2 = 1;\n\tObject.defineProperty(fdc31_2, \"__esModule\", { value: true });\n\tfdc31_2.Fdc3Module = void 0;\n\tconst utils_1 = utils$3;\n\tconst fdc3_common_1 = requireFdc3Common();\n\t/**\n\t * @version 1.2\n\t * The FDC3 Client Library provides a set APIs to be used for FDC3 compliance,\n\t * while using our Interop API under the hood. In order to use this set of APIs\n\t * you will need to set up your own {@link InteropBroker InteropBroker} or use a Platform application, which does the setup for you. Refer to our documentation on\n\t * our {@link https://developers.openfin.co/of-docs/docs/enable-color-linking Interop API}.\n\t *\n\t * To enable the FDC3 APIs in a {@link Window Window} or {@link View View}, add the fdc3InteropApi\n\t * property to its options:\n\t *\n\t * ```js\n\t * {\n\t *     autoShow: false,\n\t *     saveWindowState: true,\n\t *     url: 'https://openfin.co',\n\t *     fdc3InteropApi: '1.2'\n\t * }\n\t * ```\n\t *\n\t * If using a {@link Platform Platform } application, you can set this property in defaultWindowOptions and defaultViewOptions.\n\t *\n\t * In order to ensure that the FDC3 Api is ready before use, you can use the 'fdc3Ready' event fired on the DOM Window object:\n\t *\n\t * ```js\n\t * function fdc3Action() {\n\t *     // Make some fdc3 API calls here\n\t * }\n\t *\n\t * if (window.fdc3) {\n\t *    fdc3Action();\n\t * } else {\n\t *    window.addEventListener('fdc3Ready', fdc3Action);\n\t * }\n\t * ```\n\t */\n\tclass Fdc3Module extends fdc3_common_1.FDC3ModuleBase {\n\t    async open(app, context) {\n\t        // eslint-disable-next-line no-underscore-dangle\n\t        await super._open(app, context);\n\t    }\n\t    /**\n\t     * Add a context handler for incoming context. If an entity is part of a context group, and then sets its context handler, it will receive all of its declared contexts. If you wish to listen for all incoming contexts, pass `null` for the contextType argument.\n\t     * @param contextType - The type of context you wish to handle.\n\t     * @param handler - Handler for incoming context.\n\t     *\n\t     * @tutorial fdc3.addContextListener\n\t     * @static\n\t     */\n\t    // @ts-expect-error TODO [CORE-1524]\n\t    addContextListener(contextType, handler) {\n\t        this.wire.sendAction('fdc3-add-context-listener').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        let listener;\n\t        if (typeof contextType === 'function') {\n\t            console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');\n\t            listener = this.client.addContextHandler(contextType);\n\t        }\n\t        else {\n\t            listener = this.client.addContextHandler(handler, contextType === null ? undefined : contextType);\n\t        }\n\t        return {\n\t            ...listener,\n\t            unsubscribe: () => listener.then((l) => l.unsubscribe())\n\t        };\n\t    }\n\t    /**\n\t     * Adds a listener for incoming Intents.\n\t     * @param intent - Name of the Intent\n\t     * @param handler - Handler for incoming Intent\n\t     *\n\t     * @tutorial fdc3.addIntentListener\n\t     * @static\n\t     */\n\t    addIntentListener(intent, handler) {\n\t        this.wire.sendAction('fdc3-add-intent-listener').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const contextHandler = (raisedIntent) => {\n\t            const { context, metadata: intentMetadata } = raisedIntent;\n\t            const { metadata } = context;\n\t            const intentResolutionResultId = intentMetadata?.intentResolutionResultId || metadata?.intentResolutionResultId;\n\t            if (intentResolutionResultId) {\n\t                this.fin.InterApplicationBus.publish(intentResolutionResultId, null).catch(() => null);\n\t            }\n\t            handler(raisedIntent.context);\n\t        };\n\t        const listener = this.client.registerIntentHandler(contextHandler, intent, {\n\t            fdc3Version: '1.2'\n\t        });\n\t        return {\n\t            ...listener,\n\t            unsubscribe: () => listener.then((l) => l.unsubscribe())\n\t        };\n\t    }\n\t    /**\n\t     * Raises a specific intent.\n\t     * @param intent Name of the Intent.\n\t     * @param context Context associated with the Intent.\n\t     * @param  app App that will resolve the Intent. This is added as metadata to the Intent. Can be accessed by the app provider in {@link InteropBroker#handleFiredIntent InteropBroker.handleFiredIntent}.\n\t     *\n\t     * @tutorial fdc3.raiseIntent\n\t     * @static\n\t     */\n\t    async raiseIntent(intent, context, app) {\n\t        this.wire.sendAction('fdc3-raise-intent').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const intentObj = app\n\t            ? { name: intent, context, metadata: { target: app } }\n\t            : { name: intent, context };\n\t        try {\n\t            return await this.client.fireIntent(intentObj);\n\t        }\n\t        catch (error) {\n\t            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fireIntent ? 'ResolverUnavailable' : error.message;\n\t            throw new Error(errorToThrow);\n\t        }\n\t    }\n\t    /**\n\t     * Find out more information about a particular intent by passing its name, and optionally its context.\n\t     * @param intent Name of the Intent\n\t     * @param context\n\t     *\n\t     * @tutorial fdc3.findIntent\n\t     */\n\t    async findIntent(intent, context) {\n\t        this.wire.sendAction('fdc3-find-intent').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        try {\n\t            return await this.client.getInfoForIntent({ name: intent, context });\n\t        }\n\t        catch (error) {\n\t            const errorToThrow = error.message === utils_1.BROKER_ERRORS.getInfoForIntent ? 'ResolverUnavailable' : error.message;\n\t            throw new Error(errorToThrow);\n\t        }\n\t    }\n\t    /**\n\t     * Find all the available intents for a particular context.\n\t     * @param context\n\t     *\n\t     * @tutorial fdc3.findIntentsByContext\n\t     */\n\t    async findIntentsByContext(context) {\n\t        this.wire.sendAction('fdc3-find-intents-by-context').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        try {\n\t            return await this.client.getInfoForIntentsByContext(context);\n\t        }\n\t        catch (error) {\n\t            const errorToThrow = error.message === utils_1.BROKER_ERRORS.getInfoForIntentsByContext ? 'ResolverUnavailable' : error.message;\n\t            throw new Error(errorToThrow);\n\t        }\n\t    }\n\t    /**\n\t     * Finds and raises an intent against a target app based purely on context data.\n\t     * @param context\n\t     * @param app\n\t     *\n\t     * @tutorial fdc3.raiseIntentForContext\n\t     */\n\t    async raiseIntentForContext(context, app) {\n\t        this.wire.sendAction('fdc3-raise-intent-for-context').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        try {\n\t            return await this.client.fireIntentForContext({ ...context, metadata: { target: app } });\n\t        }\n\t        catch (error) {\n\t            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fireIntentForContext ? 'ResolverUnavailable' : error.message;\n\t            throw new Error(errorToThrow);\n\t        }\n\t    }\n\t    /**\n\t     * Returns a Channel object for the specified channel, creating it as an App Channel if it does not exist.\n\t     * @param channelId\n\t     *\n\t     * @tutorial fdc3.getOrCreateChannel\n\t     */\n\t    async getOrCreateChannel(channelId) {\n\t        return super.getOrCreateChannel(channelId);\n\t    }\n\t    /**\n\t     * Returns metadata relating to the FDC3 object and its provider, including the supported version of the FDC3 specification and the name of the provider of the implementation.\n\t     *\n\t     * @tutorial fdc3.getInfo\n\t     */\n\t    getInfo() {\n\t        this.wire.sendAction('fdc3-get-info').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const version = this.wire.environment.getAdapterVersionSync();\n\t        return {\n\t            providerVersion: version,\n\t            provider: `openfin-${this.wire.me.uuid}`,\n\t            fdc3Version: '1.2'\n\t        };\n\t    }\n\t}\n\tfdc31_2.Fdc3Module = Fdc3Module;\n\treturn fdc31_2;\n}\n\nvar fdc32_0 = {};\n\nvar hasRequiredFdc32_0;\n\nfunction requireFdc32_0 () {\n\tif (hasRequiredFdc32_0) return fdc32_0;\n\thasRequiredFdc32_0 = 1;\n\tObject.defineProperty(fdc32_0, \"__esModule\", { value: true });\n\tfdc32_0.Fdc3Module2 = void 0;\n\tconst fdc3_common_1 = requireFdc3Common();\n\tconst utils_1 = utils$3;\n\tconst InteropClient_1 = requireInteropClient();\n\tconst utils_2 = utils$2;\n\tconst PrivateChannelClient_1 = PrivateChannelClient$1;\n\t/**\n\t * @version 2.0\n\t * The FDC3 Client Library provides a set APIs to be used for FDC3 compliance,\n\t * while using our Interop API under the hood. In order to use this set of APIs\n\t * you will need to set up your own {@link InteropBroker InteropBroker} or use a Platform application, which does the setup for you. Refer to our documentation on\n\t * our {@link https://developers.openfin.co/of-docs/docs/enable-context-sharing Interop API}.\n\t *\n\t * To enable the FDC3 APIs in a {@link Window Window} or {@link View View}, add the fdc3InteropApi\n\t * property to its options:\n\t *\n\t * ```js\n\t * {\n\t *     autoShow: false,\n\t *     saveWindowState: true,\n\t *     url: 'https://openfin.co',\n\t *     fdc3InteropApi: '2.0'\n\t * }\n\t * ```\n\t *\n\t * If using a {@link Platform Platform } application, you can set this property in defaultWindowOptions and defaultViewOptions.\n\t *\n\t * In order to ensure that the FDC3 Api is ready before use, you can use the 'fdc3Ready' event fired on the DOM Window object:\n\t *\n\t * ```js\n\t * function fdc3Action() {\n\t *     // Make some fdc3 API calls here\n\t * }\n\t *\n\t * if (window.fdc3) {\n\t *    fdc3Action();\n\t * } else {\n\t *    window.addEventListener('fdc3Ready', fdc3Action);\n\t * }\n\t * ```\n\t */\n\tclass Fdc3Module2 extends fdc3_common_1.FDC3ModuleBase {\n\t    /**\n\t     * Launches an app, specified via an AppIdentifier object.\n\t     * @param app\n\t     * @param context\n\t     *\n\t     * @tutorial fdc3.open\n\t     */\n\t    async open(app, context) {\n\t        if (typeof app === 'string') {\n\t            console.warn('Passing a string as the app parameter is deprecated, please use an AppIdentifier ({ appId: string; instanceId?: string }).');\n\t        }\n\t        // eslint-disable-next-line no-underscore-dangle\n\t        return super._open(app, context);\n\t    }\n\t    /**\n\t     * Find all the available instances for a particular application.\n\t     * @param app\n\t     *\n\t     * @tutorial fdc3v2.findInstances\n\t     */\n\t    async findInstances(app) {\n\t        this.wire.sendAction('fdc3-find-instances').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        try {\n\t            return await InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'fdc3FindInstances', app);\n\t        }\n\t        catch (error) {\n\t            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fdc3FindInstances ? 'ResolverUnavailable' : error.message;\n\t            throw new Error(errorToThrow);\n\t        }\n\t    }\n\t    /**\n\t     * Retrieves the AppMetadata for an AppIdentifier, which provides additional metadata (such as icons, a title and description) from the App Directory record for the application, that may be used for display purposes.\n\t     * @param app\n\t     *\n\t     * @tutorial fdc3v2.getAppMetadata\n\t     */\n\t    async getAppMetadata(app) {\n\t        this.wire.sendAction('fdc3-get-app-metadata').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        try {\n\t            return await InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'fdc3GetAppMetadata', app);\n\t        }\n\t        catch (error) {\n\t            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fdc3GetAppMetadata ? 'ResolverUnavailable' : error.message;\n\t            throw new Error(errorToThrow);\n\t        }\n\t    }\n\t    /**\n\t     * Add a context handler for incoming context. If an entity is part of a context group, and then sets its context handler, it will receive all of its declared contexts. If you wish to listen for all incoming contexts, pass `null` for the contextType argument.\n\t     * @param contextType\n\t     * @param handler\n\t     *\n\t     * @tutorial fdc3.addContextListener\n\t     */\n\t    // @ts-expect-error TODO [CORE-1524]\n\t    async addContextListener(contextType, handler) {\n\t        this.wire.sendAction('fdc3-add-context-listener').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        // The FDC3 ContextHandler only expects the context and optional ContextMetadata, so we wrap the handler\n\t        // here so it only gets passed these parameters\n\t        const getWrappedHandler = (handlerToWrap) => {\n\t            return (context) => {\n\t                const { contextMetadata, ...rest } = context;\n\t                const args = contextMetadata ? [{ ...rest }, contextMetadata] : [context, null];\n\t                handlerToWrap(...args);\n\t            };\n\t        };\n\t        let actualHandler = handler;\n\t        let wrappedHandler = getWrappedHandler(actualHandler);\n\t        if (typeof contextType === 'function') {\n\t            console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');\n\t            actualHandler = contextType;\n\t            wrappedHandler = getWrappedHandler(actualHandler);\n\t            return this.client.addContextHandler(wrappedHandler);\n\t        }\n\t        return this.client.addContextHandler(wrappedHandler, contextType === null ? undefined : contextType);\n\t    }\n\t    /**\n\t     * Find out more information about a particular intent by passing its name, and optionally its context and resultType.\n\t     * @param intent Name of the Intent\n\t     * @param context Context\n\t     * @param resultType The type of result returned for any intent specified during resolution.\n\t     *\n\t     * @tutorial fdc3.findIntent\n\t     */\n\t    async findIntent(intent, context, resultType) {\n\t        this.wire.sendAction('fdc3-find-intent').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        try {\n\t            return await this.client.getInfoForIntent({ name: intent, context, metadata: { resultType } });\n\t        }\n\t        catch (error) {\n\t            const errorToThrow = error.message === utils_1.BROKER_ERRORS.getInfoForIntent ? 'ResolverUnavailable' : error.message;\n\t            throw new Error(errorToThrow);\n\t        }\n\t    }\n\t    /**\n\t     * Find all the available intents for a particular context.\n\t     * @param context\n\t     * @param resultType The type of result returned for any intent specified during resolution.\n\t     *\n\t     * @tutorial fdc3v2.findIntentsByContext\n\t     */\n\t    async findIntentsByContext(context, resultType) {\n\t        this.wire.sendAction('fdc3-find-intents-by-context').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const payload = resultType ? { context, metadata: { resultType } } : context;\n\t        try {\n\t            return await InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'fdc3v2FindIntentsByContext', payload);\n\t        }\n\t        catch (error) {\n\t            const errorToThrow = error.message === utils_1.BROKER_ERRORS.getInfoForIntentsByContext ? 'ResolverUnavailable' : error.message;\n\t            throw new Error(errorToThrow);\n\t        }\n\t    }\n\t    /**\n\t     * Raises a specific intent for resolution against apps registered with the desktop agent.\n\t     * @param intent Name of the Intent\n\t     * @param context Context associated with the Intent\n\t     * @param app\n\t     *\n\t     * @tutorial fdc3v2.raiseIntent\n\t     */\n\t    async raiseIntent(intent, context, app) {\n\t        this.wire.sendAction('fdc3-raise-intent').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        try {\n\t            if (typeof app === 'string') {\n\t                console.warn('Passing a string as the app parameter is deprecated, please use an AppIdentifier ({ appId: string; instanceId?: string }).');\n\t            }\n\t            return (0, utils_2.getIntentResolution)(this.client, context, app, intent);\n\t        }\n\t        catch (error) {\n\t            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fireIntent ? 'ResolverUnavailable' : error.message;\n\t            throw new Error(errorToThrow);\n\t        }\n\t    }\n\t    /**\n\t     * Finds and raises an intent against apps registered with the desktop agent based purely on the type of the context data.\n\t     * @param context Context associated with the Intent\n\t     * @param app\n\t     *\n\t     * @tutorial fdc3v2.raiseIntentForContext\n\t     */\n\t    async raiseIntentForContext(context, app) {\n\t        // TODO: We have to do the same thing we do for raiseIntent here as well.\n\t        this.wire.sendAction('fdc3-raise-intent-for-context').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        try {\n\t            if (typeof app === 'string') {\n\t                console.warn('Passing a string as the app parameter is deprecated, please use an AppIdentifier ({ appId: string; instanceId?: string }).');\n\t            }\n\t            return (0, utils_2.getIntentResolution)(this.client, context, app);\n\t        }\n\t        catch (error) {\n\t            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fireIntent ? 'ResolverUnavailable' : error.message;\n\t            throw new Error(errorToThrow);\n\t        }\n\t    }\n\t    /**\n\t     * Adds a listener for incoming intents.\n\t     * @param intent  Name of the Intent\n\t     * @param handler A callback that handles a context event and may return a promise of a Context or Channel object to be returned to the application that raised the intent.\n\t     *\n\t     * @tutorial fdc3.addIntentListener\n\t     */\n\t    async addIntentListener(intent, handler) {\n\t        this.wire.sendAction('fdc3-add-intent-listener').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        if (typeof intent !== 'string') {\n\t            throw new Error('First argument must be an Intent name');\n\t        }\n\t        // The FDC3 Intenter handler only expects the context and contextMetadata to be passed to the handler,\n\t        // so we wrap it here and only pass those paramaters.\n\t        const contextHandler = async (raisedIntent) => {\n\t            let intentResult;\n\t            let intentResultToSend;\n\t            const { context, metadata: intentMetadata } = raisedIntent;\n\t            const { contextMetadata, metadata, ...rest } = context;\n\t            const intentResolutionResultId = intentMetadata?.intentResolutionResultId || metadata?.intentResolutionResultId;\n\t            try {\n\t                const newContext = metadata ? { metadata, ...rest } : { ...rest };\n\t                intentResult = await handler(newContext, contextMetadata);\n\t                intentResultToSend = intentResult;\n\t            }\n\t            catch (error) {\n\t                intentResult = error;\n\t                intentResultToSend = { error: true };\n\t            }\n\t            if (intentResolutionResultId) {\n\t                this.fin.InterApplicationBus.publish(intentResolutionResultId, intentResultToSend).catch(() => null);\n\t            }\n\t            if (intentResult instanceof Error) {\n\t                throw new Error(intentResult.message);\n\t            }\n\t            return intentResult;\n\t        };\n\t        return this.client.registerIntentHandler(contextHandler, intent, { fdc3Version: '2.0' });\n\t    }\n\t    /**\n\t     * Returns a Channel object for the specified channel, creating it as an App Channel if it does not exist.\n\t     * @param channelId\n\t     *\n\t     * @tutorial fdc3.getOrCreateChannel\n\t     */\n\t    async getOrCreateChannel(channelId) {\n\t        return super.getOrCreateChannel(channelId);\n\t    }\n\t    /**\n\t     * Returns a Channel with an auto-generated identity that is intended for private communication between applications. Primarily used to create channels that will be returned to other applications via an IntentResolution for a raised intent.\n\t     *\n\t     * @tutorial fdc3v2.createPrivateChannel\n\t     */\n\t    async createPrivateChannel() {\n\t        const channelId = (0, utils_1.generateId)();\n\t        await InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'createPrivateChannelProvider', { channelId });\n\t        const channelClient = await this.fin.InterApplicationBus.Channel.connect(channelId);\n\t        const newPrivateChannelClient = new PrivateChannelClient_1.PrivateChannelClient(channelClient, channelId);\n\t        return (0, utils_2.buildPrivateChannelObject)(newPrivateChannelClient);\n\t    }\n\t    /**\n\t     * Retrieves a list of the User Channels available for the app to join.\n\t     *\n\t     * @tutorial fdc3v2.getUserChannels\n\t     */\n\t    async getUserChannels() {\n\t        const channels = await this.client.getContextGroups();\n\t        // fdc3 implementation of getUserChannels returns on array of channels, have to decorate over\n\t        // this so people know that these APIs are not supported\n\t        return channels.map((channel) => {\n\t            // @ts-expect-error TODO [CORE-1524]\n\t            return { ...channel, type: 'user', ...(0, utils_2.getUnsupportedChannelApis)('User') };\n\t        });\n\t    }\n\t    /**\n\t     * Retrieves a list of the User Channels available for the app to join.\n\t     *\n\t     * @deprecated Please use {@link fdc3.getUserChannels fdc3.getUserChannels} instead\n\t     * @tutorial fdc3.getSystemChannels\n\t     */\n\t    async getSystemChannels() {\n\t        console.warn('This API has been deprecated. Please use fdc3.getUserChannels instead.');\n\t        return super.getSystemChannels();\n\t    }\n\t    /**\n\t     * Join an app to a specified User channel.\n\t     * @param channelId Channel name\n\t     *\n\t     * @tutorial fdc3v2.joinUserChannel\n\t     */\n\t    async joinUserChannel(channelId) {\n\t        return super.joinChannel(channelId);\n\t    }\n\t    /**\n\t     * Join an app to a specified User channel.\n\t     * @param channelId Channel name\n\t     * @deprecated Please use {@link fdc3.joinUserChannel fdc3.joinUserChannel} instead\n\t     *\n\t     * @tutorial fdc3.joinChannel\n\t     */\n\t    async joinChannel(channelId) {\n\t        console.warn('This API has been deprecated. Please use fdc3.joinUserChannel instead.');\n\t        return super.joinChannel(channelId);\n\t    }\n\t    /**\n\t     * Returns the Channel object for the current User channel membership\n\t     *\n\t     * @tutorial fdc3.getCurrentChannel\n\t     */\n\t    async getCurrentChannel() {\n\t        const currentChannel = await super.getCurrentChannel();\n\t        if (!currentChannel) {\n\t            return null;\n\t        }\n\t        return {\n\t            ...currentChannel,\n\t            type: 'user',\n\t            broadcast: this.broadcast.bind(this)\n\t        };\n\t    }\n\t    /**\n\t     * Retrieves information about the FDC3 implementation, including the supported version of the FDC3 specification, the name of the provider of the implementation, its own version number, details of whether optional API features are implemented and the metadata of the calling application according to the desktop agent.\n\t     * fdc3HandleGetInfo must be overridden in the InteropBroker so that the ImplementationMetadata will have the appMetadata info.\n\t     *\n\t     * @tutorial fdc3v2.getInfo\n\t     */\n\t    async getInfo() {\n\t        return InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'fdc3v2GetInfo', { fdc3Version: '2.0' });\n\t    }\n\t}\n\tfdc32_0.Fdc3Module2 = Fdc3Module2;\n\treturn fdc32_0;\n}\n\nvar hasRequiredInteropClient;\n\nfunction requireInteropClient () {\n\tif (hasRequiredInteropClient) return InteropClient;\n\thasRequiredInteropClient = 1;\n\tvar __classPrivateFieldSet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n\t    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n\t    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n\t    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n\t    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n\t};\n\tvar __classPrivateFieldGet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n\t    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n\t    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n\t    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n\t};\n\tvar __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {\n\t    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n\t};\n\tvar _InteropClient_clientPromise, _InteropClient_sessionContextGroups;\n\tObject.defineProperty(InteropClient, \"__esModule\", { value: true });\n\tInteropClient.InteropClient = void 0;\n\tconst base_1 = base;\n\tconst SessionContextGroupClient_1 = __importDefault(SessionContextGroupClient$1);\n\tconst fdc3_1_2_1 = requireFdc31_2();\n\tconst fdc3_2_0_1 = requireFdc32_0();\n\tconst utils_1 = utils$3;\n\t/**\n\t * The Interop Client API is broken up into two groups:\n\t *\n\t * **Content Facing APIs** - For Application Developers putting Views into a Platform Window, who care about Context. These are APIs that send out and receive the Context data that flows between applications. Think of this as the Water in the Interop Pipes.\n\t *\n\t * **Context Grouping APIs** - For Platform Developers, to add and remove Views to and from Context Groups. These APIs are utilized under-the-hood in Platforms, so they don't need to be used to participate in Interop. These are the APIs that decide which entities the context data flows between. Think of these as the valves or pipes that control the flow of Context Data for Interop.\n\t *\n\t * ---\n\t *\n\t * All APIs are available at the `fin.me.interop` namespace.\n\t *\n\t * ---\n\t *\n\t * **You only need 2 things to participate in Interop Context Grouping:**\n\t * * A Context Handler for incoming context: {@link InteropClient#addContextHandler addContextHandler(handler, contextType?)}\n\t * * Call setContext on your context group when you want to share context with other group members: {@link InteropClient#setContext setContext(context)}\n\t *\n\t * ---\n\t *\n\t * ##### Constructor\n\t * Returned by {@link Interop.connectSync Interop.connectSync}.\n\t *\n\t * ---\n\t *\n\t * ##### Interop methods intended for Views\n\t *\n\t *\n\t * **Context Groups API**\n\t *  * {@link InteropClient#addContextHandler addContextHandler(handler, contextType?)}\n\t *  * {@link InteropClient#setContext setContext(context)}\n\t *  * {@link InteropClient#getCurrentContext getCurrentContext(contextType?)}\n\t *  * {@link InteropClient#joinSessionContextGroup joinSessionContextGroup(sessionContextGroupId)}\n\t *\n\t *\n\t * **Intents API**\n\t *  * {@link InteropClient#fireIntent fireIntent(intent)}\n\t *  * {@link InteropClient#registerIntentHandler registerIntentHandler(intentHandler, intentName)}\n\t *  * {@link InteropClient#getInfoForIntent getInfoForIntent(infoForIntentOptions)}\n\t *  * {@link InteropClient#getInfoForIntentsByContext getInfoForIntentsByContext(context)}\n\t *  * {@link InteropClient#fireIntentForContext fireIntentForContext(contextForIntent)}\n\t *\n\t * ##### Interop methods intended for Windows\n\t *  * {@link InteropClient#getContextGroups getContextGroups()}\n\t *  * {@link InteropClient#joinContextGroup joinContextGroup(contextGroupId, target?)}\n\t *  * {@link InteropClient#removeFromContextGroup removeFromContextGroup(target?)}\n\t *  * {@link InteropClient#getInfoForContextGroup getInfoForContextGroup(contextGroupId)}\n\t *  * {@link InteropClient#getAllClientsInContextGroup getAllClientsInContextGroup(contextGroupId)}\n\t *\n\t */\n\tlet InteropClient$1 = class InteropClient extends base_1.Base {\n\t    /**\n\t     * @internal\n\t     */\n\t    constructor(wire, clientPromise) {\n\t        super(wire);\n\t        _InteropClient_clientPromise.set(this, void 0);\n\t        _InteropClient_sessionContextGroups.set(this, void 0);\n\t        __classPrivateFieldSet(this, _InteropClient_sessionContextGroups, new Map(), \"f\");\n\t        __classPrivateFieldSet(this, _InteropClient_clientPromise, clientPromise, \"f\");\n\t    }\n\t    /*\n\t    Client APIs\n\t    */\n\t    /**\n\t     * Sets a context for the context group of the current entity.\n\t     *\n\t     * @remarks The entity must be part of a context group in order set a context.\n\t     *\n\t     * @param context - New context to set.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * setInstrumentContext = async (ticker) => {\n\t     *     fin.me.interop.setContext({type: 'instrument', id: {ticker}})\n\t     * }\n\t     *\n\t     * // The user clicks an instrument of interest. We want to set that Instrument context so that the rest of our workflow updates with information for that instrument\n\t     * instrumentElement.on('click', (evt) => {\n\t     *     setInstrumentContext(evt.ticker)\n\t     * })\n\t     * ```\n\t     */\n\t    async setContext(context) {\n\t        this.wire.sendAction('interop-client-set-context').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        return client.dispatch('setContext', { context });\n\t    }\n\t    /**\n\t     * Add a context handler for incoming context. If an entity is part of a context group, and then sets its context handler,\n\t     * it will receive all of its declared contexts.\n\t     *\n\t     * @param handler - Handler for incoming context.\n\t     * @param contextType - The type of context you wish to handle.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * function handleIncomingContext(contextInfo) {\n\t     *     const { type, id } = contextInfo;\n\t     *     switch (type) {\n\t     *         case 'instrument':\n\t     *             handleInstrumentContext(contextInfo);\n\t     *             break;\n\t     *         case 'country':\n\t     *             handleCountryContext(contextInfo);\n\t     *             break;\n\t     *\n\t     *         default:\n\t     *             break;\n\t     *     }\n\t     * }\n\t     *\n\t     *\n\t     * function handleInstrumentContext(contextInfo) {\n\t     *     const { type, id } = contextInfo;\n\t     *     console.log('contextInfo for instrument', contextInfo)\n\t     * }\n\t     *\n\t     * function handleCountryContext(contextInfo) {\n\t     *     const { type, id } = contextInfo;\n\t     *     console.log('contextInfo for country', contextInfo)\n\t     * }\n\t     *\n\t     * fin.me.interop.addContextHandler(handleIncomingContext);\n\t     * ```\n\t     *\n\t     *\n\t     * Passing in a context type as the second parameter will cause the handler to only be invoked with that context type.\n\t     *\n\t     * ```js\n\t     * function handleInstrumentContext(contextInfo) {\n\t     *     const { type, id } = contextInfo;\n\t     *     console.log('contextInfo for instrument', contextInfo)\n\t     * }\n\t     *\n\t     * function handleCountryContext(contextInfo) {\n\t     *     const { type, id } = contextInfo;\n\t     *     console.log('contextInfo for country', contextInfo)\n\t     * }\n\t     *\n\t     *\n\t     * fin.me.interop.addContextHandler(handleInstrumentContext, 'instrument')\n\t     * fin.me.interop.addContextHandler(handleCountryContext, 'country')\n\t     * ```\n\t     */\n\t    async addContextHandler(handler, contextType) {\n\t        this.wire.sendAction('interop-client-add-context-handler').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        if (typeof handler !== 'function') {\n\t            throw new Error(\"Non-function argument passed to the first parameter 'handler'. Be aware that the argument order does not match the FDC3 standard.\");\n\t        }\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        let handlerId;\n\t        if (contextType) {\n\t            handlerId = `invokeContextHandler-${contextType}-${(0, utils_1.generateId)()}`;\n\t        }\n\t        else {\n\t            handlerId = 'invokeContextHandler';\n\t        }\n\t        const wrappedHandler = (0, utils_1.wrapContextHandler)(handler, handlerId);\n\t        client.register(handlerId, wrappedHandler);\n\t        await client.dispatch('contextHandlerRegistered', { handlerId, contextType });\n\t        return {\n\t            unsubscribe: async () => {\n\t                client.remove(handlerId);\n\t                await client.dispatch('removeContextHandler', { handlerId });\n\t            }\n\t        };\n\t    }\n\t    /*\n\t    Platform Window APIs\n\t    */\n\t    /**\n\t     * Returns the Interop-Broker-defined context groups available for an entity to join.\n\t     * Used by Platform Windows.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.me.interop.getContextGroups()\n\t     *         .then(contextGroups => {\n\t     *             contextGroups.forEach(contextGroup => {\n\t     *                 console.log(contextGroup.displayMetadata.name)\n\t     *                 console.log(contextGroup.displayMetadata.color)\n\t     *             })\n\t     *         })\n\t     * ```\n\t     */\n\t    async getContextGroups() {\n\t        this.wire.sendAction('interop-client-get-context-groups').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        return client.dispatch('getContextGroups');\n\t    }\n\t    /**\n\t     * Join all Interop Clients at the given identity to context group `contextGroupId`.\n\t     * If no target is specified, it adds the sender to the context group.\n\t     *\n\t     * @remarks Because multiple Channel connections/Interop Clients can potentially exist at a `uuid`/`name` combo, we currently join all Channel connections/Interop Clients at the given identity to the context group.\n\t     * If an `endpointId` is provided (which is unlikely, unless the call is coming from an external adapter), then we only join that single connection to the context group.\n\t     * For all intents and purposes, there will only be 1 connection present in Platform and Browser implmentations, so this point is more-or-less moot.\n\t     * Used by Platform Windows.\n\t     *\n\t     * @param contextGroupId - Id of the context group.\n\t     * @param target - Identity of the entity you wish to join to a context group.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * joinViewToContextGroup = async (contextGroupId, view) => {\n\t     *     await fin.me.interop.joinContextGroup(contextGroupId, view);\n\t     * }\n\t     *\n\t     * getLastFocusedView()\n\t     *     .then(lastFocusedViewIdentity => {\n\t     *         joinViewToContextGroup('red', lastFocusedViewIdentity)\n\t     *     })\n\t     * ```\n\t     */\n\t    async joinContextGroup(contextGroupId, target) {\n\t        this.wire.sendAction('interop-client-join-context-group').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        if (!contextGroupId) {\n\t            throw new Error('No contextGroupId specified for joinContextGroup.');\n\t        }\n\t        return client.dispatch('joinContextGroup', { contextGroupId, target });\n\t    }\n\t    /**\n\t     * Removes the specified target from a context group.\n\t     * If no target is specified, it removes the sender from their context group.\n\t     * Used by Platform Windows.\n\t     *\n\t     * @param target - Identity of the entity you wish to join to a context group.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * removeViewFromContextGroup = async (view) => {\n\t     *     await fin.me.interop.removeFromContextGroup(view);\n\t     * }\n\t     *\n\t     * getLastFocusedView()\n\t     *     .then(lastFocusedViewIdentity => {\n\t     *         removeViewFromContextGroup(lastFocusedViewIdentity)\n\t     *     })\n\t     * ```\n\t     */\n\t    async removeFromContextGroup(target) {\n\t        this.wire.sendAction('interop-client-remove-from-context-group').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        return client.dispatch('removeFromContextGroup', { target });\n\t    }\n\t    /**\n\t     * Gets all clients for a context group.\n\t     *\n\t     * @remarks **This is primarily used for platform windows. Views within a platform should not have to use this API.**\n\t     *\n\t     * Returns the Interop-Broker-defined context groups available for an entity to join.\n\t     * @param contextGroupId - The id of context group you wish to get clients for.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.me.interop.getAllClientsInContextGroup('red')\n\t     *     .then(clientsInContextGroup => {\n\t     *         console.log(clientsInContextGroup)\n\t     *     })\n\t     * ```\n\t     */\n\t    async getAllClientsInContextGroup(contextGroupId) {\n\t        this.wire.sendAction('interop-client-get-all-clients-in-context-group').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        if (!contextGroupId) {\n\t            throw new Error('No contextGroupId specified for getAllClientsInContextGroup.');\n\t        }\n\t        return client.dispatch('getAllClientsInContextGroup', { contextGroupId });\n\t    }\n\t    /**\n\t     * Gets display info for a context group\n\t     *\n\t     * @remarks Used by Platform Windows.\n\t     * @param contextGroupId - The id of context group you wish to get display info for.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.me.interop.getInfoForContextGroup('red')\n\t     *     .then(contextGroupInfo => {\n\t     *         console.log(contextGroupInfo.displayMetadata.name)\n\t     *         console.log(contextGroupInfo.displayMetadata.color)\n\t     *     })\n\t     * ```\n\t     */\n\t    async getInfoForContextGroup(contextGroupId) {\n\t        this.wire.sendAction('interop-client-get-info-for-context-group').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        if (!contextGroupId) {\n\t            throw new Error('No contextGroupId specified for getInfoForContextGroup.');\n\t        }\n\t        return client.dispatch('getInfoForContextGroup', { contextGroupId });\n\t    }\n\t    /**\n\t     * Sends an intent to the Interop Broker to resolve.\n\t     * @param intent - The combination of an action and a context that is passed to an application for resolution.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * // View wants to fire an Intent after a user clicks on a ticker\n\t     * tickerElement.on('click', (element) => {\n\t     *     const ticker = element.innerText;\n\t     *     const intent = {\n\t     *         name: 'ViewChart',\n\t     *         context: {type: 'fdc3.instrument', id: { ticker }}\n\t     *     }\n\t     *\n\t     *     fin.me.interop.fireIntent(intent);\n\t     * })\n\t     * ```\n\t     */\n\t    async fireIntent(intent) {\n\t        this.wire.sendAction('interop-client-fire-intent').catch((e) => {\n\t            // don't expose, this is only for api analytics purposes\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        return client.dispatch('fireIntent', intent);\n\t    }\n\t    /**\n\t     * Adds an intent handler for incoming intents. The last intent sent of the name subscribed to will be received.\n\t     * @param handler - Registered function meant to handle a specific intent type.\n\t     * @param intentName - The name of an intent.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * const intentHandler = (intent) => {\n\t     *     const { context } = intent;\n\t     *     myViewChartHandler(context);\n\t     * };\n\t     *\n\t     * const subscription = await fin.me.interop.registerIntentHandler(intentHandler, 'ViewChart');\n\t     *\n\t     * function myAppCloseSequence() {\n\t     *     // to unsubscribe the handler, simply call:\n\t     *     subscription.unsubscribe();\n\t     * }\n\t     * ```\n\t     */\n\t    async registerIntentHandler(handler, intentName, options) {\n\t        this.wire.sendAction('interop-client-register-intent-handler').catch((e) => {\n\t            // don't expose, this is only for api analytics purposes\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        const handlerId = `intent-handler-${intentName}`;\n\t        const wrappedHandler = (0, utils_1.wrapIntentHandler)(handler, handlerId);\n\t        try {\n\t            await client.register(handlerId, wrappedHandler);\n\t            await client.dispatch('intentHandlerRegistered', { handlerId, ...options });\n\t        }\n\t        catch (error) {\n\t            throw new Error('Unable to register intent handler');\n\t        }\n\t        return {\n\t            unsubscribe: async () => {\n\t                client.remove(handlerId);\n\t            }\n\t        };\n\t    }\n\t    /**\n\t     * Gets the last context of the Context Group currently subscribed to. It takes an optional Context Type and returns the\n\t     * last context of that type.\n\t     * @param contextType\n\t     *\n\t     * @example\n\t     * ```js\n\t     * await fin.me.interop.joinContextGroup('yellow');\n\t     * await fin.me.interop.setContext({ type: 'instrument', id: { ticker: 'FOO' }});\n\t     * const currentContext = await fin.me.interop.getCurrentContext();\n\t     *\n\t     * // with a specific context\n\t     * await fin.me.interop.joinContextGroup('yellow');\n\t     * await fin.me.interop.setContext({ type: 'country', id: { ISOALPHA3: 'US' }});\n\t     * await fin.me.interop.setContext({ type: 'instrument', id: { ticker: 'FOO' }});\n\t     * const currentContext = await fin.me.interop.getCurrentContext('country');\n\t     * ```\n\t     */\n\t    async getCurrentContext(contextType) {\n\t        this.wire.sendAction('interop-client-get-current-context').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        return client.dispatch('getCurrentContext', { contextType });\n\t    }\n\t    /**\n\t     * Get information for a particular Intent from the Interop Broker.\n\t     *\n\t     * @remarks To resolve this info, the function handleInfoForIntent is meant to be overridden in the Interop Broker.\n\t     * The format for the response will be determined by the App Provider overriding the function.\n\t     *\n\t     * @param options\n\t     *\n\t     * @example\n\t     * ```js\n\t     * const intentInfo = await fin.me.interop.getInfoForIntent('ViewChart');\n\t     * ```\n\t     */\n\t    async getInfoForIntent(options) {\n\t        this.wire.sendAction('interop-client-get-info-for-intent').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        return client.dispatch('getInfoForIntent', options);\n\t    }\n\t    /**\n\t     * Get information from the Interop Broker on all Intents that are meant to handle a particular context.\n\t     *\n\t     * @remarks To resolve this info, the function handleInfoForIntentsByContext is meant to be overridden in the Interop Broker.\n\t     * The format for the response will be determined by the App Provider overriding the function.\n\t     *\n\t     * @param context\n\t     *\n\t     * @example\n\t     * ```js\n\t     * tickerElement.on('click', (element) => {\n\t     *     const ticker = element.innerText;\n\t     *\n\t     *     const context = {\n\t     *         type: 'fdc3.instrument',\n\t     *         id: {\n\t     *             ticker\n\t     *         }\n\t     *     }\n\t     *\n\t     *     const intentsInfo = await fin.me.interop.getInfoForIntentByContext(context);\n\t     * })\n\t     * ```\n\t     */\n\t    async getInfoForIntentsByContext(context) {\n\t        this.wire.sendAction('interop-client-get-info-for-intents-by-context').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        return client.dispatch('getInfoForIntentsByContext', context);\n\t    }\n\t    /**\n\t     * Sends a Context that will be resolved to an Intent by the Interop Broker.\n\t     * This context accepts a metadata property.\n\t     *\n\t     * @remarks To resolve this info, the function handleFiredIntentByContext is meant to be overridden in the Interop Broker.\n\t     * The format for the response will be determined by the App Provider overriding the function.\n\t     *\n\t     * @param context\n\t     *\n\t     * @example\n\t     * ```js\n\t     * tickerElement.on('click', (element) => {\n\t     *     const ticker = element.innerText;\n\t     *\n\t     *     const context = {\n\t     *         type: 'fdc3.instrument',\n\t     *         id: {\n\t     *             ticker\n\t     *         }\n\t     *     }\n\t     *\n\t     *     const intentResolution = await fin.me.interop.fireIntentForContext(context);\n\t     * })\n\t     * ```\n\t     */\n\t    async fireIntentForContext(context) {\n\t        this.wire.sendAction('interop-client-fire-intent-for-context').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        return client.dispatch('fireIntentForContext', context);\n\t    }\n\t    /**\n\t     * Join the current entity to session context group `sessionContextGroupId` and return a sessionContextGroup instance.\n\t     * If the sessionContextGroup doesn't exist, one will get created.\n\t     *\n\t     * @remarks Session Context Groups do not persist between runs and aren't present on snapshots.\n\t     * @param sessionContextGroupId - Id of the context group.\n\t     *\n\t     * @example\n\t     * Say we want to have a Session Context Group that holds UI theme information for all apps to consume:\n\t     *\n\t     * My color-picker View:\n\t     * ```js\n\t     *     const themeSessionContextGroup = await fin.me.interop.joinSessionContextGroup('theme');\n\t     *\n\t     *     const myColorPickerElement = document.getElementById('color-palette-picker');\n\t     *     myColorPickerElement.addEventListener('change', event => {\n\t     *         themeSessionContextGroup.setContext({ type: 'color-palette', selection: event.value });\n\t     *     });\n\t     * ```\n\t     *\n\t     * In other views:\n\t     * ```js\n\t     *     const themeSessionContextGroup = await fin.me.interop.joinSessionContextGroup('theme');\n\t     *\n\t     *     const changeColorPalette = ({ selection }) => {\n\t     *         // change the color palette to the selection\n\t     *     };\n\t     *\n\t     *     // If the context is already set by the time the handler was set, the handler will get invoked immediately with the current context.\n\t     *     themeSessionContextGroup.addContextHandler(changeColorPalette, 'color-palette');\n\t     * ```\n\t     */\n\t    async joinSessionContextGroup(sessionContextGroupId) {\n\t        try {\n\t            const currentSessionContextGroup = __classPrivateFieldGet(this, _InteropClient_sessionContextGroups, \"f\").get(sessionContextGroupId);\n\t            if (currentSessionContextGroup) {\n\t                return currentSessionContextGroup.getUserInstance();\n\t            }\n\t            const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t            const { hasConflict } = await client.dispatch('sessionContextGroup:createIfNeeded', {\n\t                sessionContextGroupId\n\t            });\n\t            if (hasConflict) {\n\t                console.warn(`A (non-session) context group with the name \"${sessionContextGroupId}\" already exists. If you are trying to join a Context Group, call joinContextGroup instead.`);\n\t            }\n\t            const newSessionContextGroup = new SessionContextGroupClient_1.default(this.wire, __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\"), sessionContextGroupId);\n\t            __classPrivateFieldGet(this, _InteropClient_sessionContextGroups, \"f\").set(sessionContextGroupId, newSessionContextGroup);\n\t            return newSessionContextGroup.getUserInstance();\n\t        }\n\t        catch (error) {\n\t            console.error(`Error thrown trying to create Session Context Group with id \"${sessionContextGroupId}\": ${error}`);\n\t            throw error;\n\t        }\n\t    }\n\t    /**\n\t     * Register a listener that is called when the Interop Client has been disconnected from the Interop Broker.\n\t     * Only one listener per Interop Client can be set.\n\t     * @param listener\n\t     *\n\t     * @example\n\t     * ```js\n\t     * const listener = (event) => {\n\t     *     const { type, topic, brokerName} = event;\n\t     *     console.log(`Disconnected from Interop Broker ${brokerName} `);\n\t     * }\n\t     *\n\t     * await fin.me.interop.onDisconnection(listener);\n\t     * ```\n\t     */\n\t    async onDisconnection(listener) {\n\t        this.wire.sendAction('interop-client-add-ondisconnection-listener').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        return client.onDisconnection((event) => {\n\t            const { uuid } = event;\n\t            listener({ type: 'interop-broker', topic: 'disconnected', brokerName: uuid });\n\t        });\n\t    }\n\t    getFDC3Sync(version) {\n\t        switch (version) {\n\t            case '1.2':\n\t                return new fdc3_1_2_1.Fdc3Module(() => this, this.wire);\n\t            case '2.0':\n\t                return new fdc3_2_0_1.Fdc3Module2(() => this, this.wire);\n\t            default:\n\t                throw new Error(`Invalid FDC3 version provided: ${version}. Must be '1.2' or '2.0'`);\n\t        }\n\t    }\n\t    async getFDC3(version) {\n\t        return this.getFDC3Sync(version);\n\t    }\n\t    /**\n\t     * @internal\n\t     *\n\t     * Used to ferry fdc3-only calls from the fdc3 shim to the Interop Broker\n\t     */\n\t    static async ferryFdc3Call(interopClient, action, payload) {\n\t        const client = await __classPrivateFieldGet(interopClient, _InteropClient_clientPromise, \"f\");\n\t        return client.dispatch(action, payload || null);\n\t    }\n\t};\n\tInteropClient.InteropClient = InteropClient$1;\n\t_InteropClient_clientPromise = new WeakMap(), _InteropClient_sessionContextGroups = new WeakMap();\n\treturn InteropClient;\n}\n\nvar overrideCheck = {};\n\nvar hasRequiredOverrideCheck;\n\nfunction requireOverrideCheck () {\n\tif (hasRequiredOverrideCheck) return overrideCheck;\n\thasRequiredOverrideCheck = 1;\n\tObject.defineProperty(overrideCheck, \"__esModule\", { value: true });\n\toverrideCheck.overrideCheck = overrideCheck.checkFDC32Overrides = overrideCheck.getDefaultViewFdc3VersionFromAppInfo = void 0;\n\tconst InteropBroker_1 = requireInteropBroker();\n\tfunction getDefaultViewFdc3VersionFromAppInfo({ manifest, initialOptions }) {\n\t    const setVersion = manifest?.platform?.defaultViewOptions?.fdc3InteropApi ?? initialOptions.defaultViewOptions?.fdc3InteropApi;\n\t    return ['1.2', '2.0'].includes(setVersion ?? '') ? setVersion : undefined;\n\t}\n\toverrideCheck.getDefaultViewFdc3VersionFromAppInfo = getDefaultViewFdc3VersionFromAppInfo;\n\tfunction checkFDC32Overrides(overriddenBroker) {\n\t    // These are the APIs that must be overridden for FDC3 2.0 compliance\n\t    const mustOverrideAPIs = [\n\t        'fdc3HandleFindInstances',\n\t        'handleInfoForIntent',\n\t        'handleInfoForIntentsByContext',\n\t        'fdc3HandleGetAppMetadata',\n\t        'fdc3HandleGetInfo',\n\t        'fdc3HandleOpen',\n\t        'handleFiredIntent',\n\t        'handleFiredIntentForContext'\n\t    ];\n\t    return mustOverrideAPIs.filter((api) => {\n\t        return overriddenBroker[api] === InteropBroker_1.InteropBroker.prototype[api];\n\t    });\n\t}\n\toverrideCheck.checkFDC32Overrides = checkFDC32Overrides;\n\tfunction overrideCheck$1(overriddenBroker, fdc3InteropApi) {\n\t    if (fdc3InteropApi && fdc3InteropApi === '2.0') {\n\t        const notOverridden = checkFDC32Overrides(overriddenBroker);\n\t        if (notOverridden.length > 0) {\n\t            console.warn(`WARNING: FDC3 2.0 has been set as a default option for Views in this Platform, but the required InteropBroker APIs for FDC3 2.0 compliance have not all been overridden.\\nThe following APIs need to be overridden:\\n${notOverridden.join('\\n')}`);\n\t        }\n\t    }\n\t}\n\toverrideCheck.overrideCheck = overrideCheck$1;\n\treturn overrideCheck;\n}\n\nvar hasRequiredFactory;\n\nfunction requireFactory () {\n\tif (hasRequiredFactory) return Factory$1;\n\thasRequiredFactory = 1;\n\tvar __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {\n\t    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n\t};\n\tObject.defineProperty(Factory$1, \"__esModule\", { value: true });\n\tFactory$1.InteropModule = void 0;\n\tconst cloneDeep_1 = __importDefault(require$$0$1);\n\tconst inaccessibleObject_1 = inaccessibleObject;\n\tconst base_1 = base;\n\tconst InteropBroker_1 = requireInteropBroker();\n\tconst InteropClient_1 = requireInteropClient();\n\tconst overrideCheck_1 = requireOverrideCheck();\n\tconst common_utils_1 = commonUtils;\n\tconst defaultOverride = (Class) => new Class();\n\tconst BrokerParamAccessError = 'You have attempted to use or modify InteropBroker parameters, which is not allowed. You are likely using an older InteropBroker override scheme. Please consult our Interop docs for guidance on migrating to the new override scheme.';\n\t/**\n\t * Manages creation of Interop Brokers and Interop Clients. These APIs are called under-the-hood in Platforms.\n\t *\n\t */\n\tclass InteropModule extends base_1.Base {\n\t    /**\n\t     * Initializes an Interop Broker. This is called under-the-hood for Platforms.\n\t     *\n\t     * @remarks For Platforms, this is set up automatically. We advise to only create your own Interop Broker\n\t     * when not using a Platform app. You can override functions in the Interop Broker. More info {@link InteropBroker here}.\n\t     *\n\t     * @param name - Name of the Interop Broker.\n\t     * @param override - A callback function or array of callback functions that can be used to extend or replace default Interop Broker behavior.\n\t     *\n\t     * @example\n\t     * ``` js\n\t     * const interopBroker = await fin.Interop.init('openfin');\n\t     * const contextGroups = await interopBroker.getContextGroups();\n\t     * console.log(contextGroups);\n\t     * ```\n\t     */\n\t    async init(name, override = defaultOverride) {\n\t        this.wire.sendAction('interop-init').catch(() => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        // Allows for manifest-level configuration, without having to override. (e.g. specifying custom context groups)\n\t        const options = await this.wire.environment.getInteropInfo(this.wire.getFin());\n\t        const objectThatThrows = (0, inaccessibleObject_1.createUnusableObject)(BrokerParamAccessError);\n\t        const warningOptsClone = (0, inaccessibleObject_1.createWarningObject)(BrokerParamAccessError, (0, cloneDeep_1.default)(options));\n\t        const getProvider = () => {\n\t            return this.fin.InterApplicationBus.Channel.create(`interop-broker-${name}`);\n\t        };\n\t        const throwingGetProvider = async () => {\n\t            // eslint-disable-next-line no-console\n\t            throw new Error(BrokerParamAccessError);\n\t        };\n\t        const OverrideableBroker = InteropBroker_1.InteropBroker.createClosedConstructor(this.wire, getProvider, options);\n\t        let broker;\n\t        if (Array.isArray(override)) {\n\t            const BrokerConstructor = (0, common_utils_1.overrideFromComposables)(...override)(OverrideableBroker);\n\t            // We need to use these objects because removing them entirely would be a breaking change and we want an informative error\n\t            // @ts-expect-error\n\t            broker = new BrokerConstructor(objectThatThrows, throwingGetProvider, warningOptsClone);\n\t        }\n\t        else {\n\t            // We need to use these objects because removing them entirely would be a breaking change and we want an informative error\n\t            // @ts-expect-error\n\t            broker = await override(OverrideableBroker, objectThatThrows, throwingGetProvider, warningOptsClone);\n\t        }\n\t        (0, overrideCheck_1.overrideCheck)(broker, options.fdc3Version);\n\t        return broker;\n\t    }\n\t    /**\n\t     * Connects a client to an Interop broker. This is called under-the-hood for Views in a Platform.\n\t     *\n\t     * @remarks\n\t     * @param name - The name of the Interop Broker to connect to. For Platforms, this will default to the uuid of the Platform.\n\t     * @param interopConfig - Information relevant to the Interop Broker. Typically a declaration of\n\t     * what context(s) the entity wants to subscribe to, and the current Context Group of the entity.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * const interopConfig = {\n\t     *     currentContextGroup: 'green'\n\t     * }\n\t     *\n\t     * const interopBroker = await fin.Interop.init('openfin');\n\t     * const client = await fin.Interop.connectSync('openfin', interopConfig);\n\t     * const contextGroupInfo = await client.getInfoForContextGroup();\n\t     * console.log(contextGroupInfo);\n\t     * ```\n\t     */\n\t    connectSync(name, interopConfig) {\n\t        this.wire.sendAction('interop-connect-sync').catch(() => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        return new InteropClient_1.InteropClient(this.wire, this.wire.environment.whenReady().then(() => {\n\t            return this.fin.InterApplicationBus.Channel.connect(`interop-broker-${name}`, {\n\t                payload: interopConfig\n\t            });\n\t        }));\n\t    }\n\t}\n\tFactory$1.InteropModule = InteropModule;\n\treturn Factory$1;\n}\n\nvar hasRequiredInterop;\n\nfunction requireInterop () {\n\tif (hasRequiredInterop) return interop;\n\thasRequiredInterop = 1;\n\t(function (exports) {\n\t\t/**\n\t\t * Entry point for the OpenFin `Interop` API (`fin.Interop`).\n\t\t *\n\t\t * * {@link InteropModule} contains static members of the `Interop` API (available under `fin.Interop`)\n\t\t * * {@link InteropClient} and {@link InteropBroker} document instances of their respective classes.\n\t\t *\n\t\t * @packageDocumentation\n\t\t */\n\t\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t\t    if (k2 === undefined) k2 = k;\n\t\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t\t    }\n\t\t    Object.defineProperty(o, k2, desc);\n\t\t}) : (function(o, m, k, k2) {\n\t\t    if (k2 === undefined) k2 = k;\n\t\t    o[k2] = m[k];\n\t\t}));\n\t\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t\t};\n\t\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t\t__exportStar(requireFactory(), exports);\n\t\t__exportStar(requireInteropClient(), exports);\n\t\t__exportStar(requireInteropBroker(), exports); \n\t} (interop));\n\treturn interop;\n}\n\nvar snapshotSource = {};\n\nvar Factory = {};\n\nvar Instance = {};\n\nvar utils = {};\n\nObject.defineProperty(utils, \"__esModule\", { value: true });\nutils.getSnapshotSourceChannelName = void 0;\nconst channelPrefix = 'snapshot-source-provider-';\nconst getSnapshotSourceChannelName = (id) => `${channelPrefix}${id.uuid}`;\nutils.getSnapshotSourceChannelName = getSnapshotSourceChannelName;\n\nvar __classPrivateFieldSet$1 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar __classPrivateFieldGet$1 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar _SnapshotSource_identity, _SnapshotSource_getConnection, _SnapshotSource_getClient, _SnapshotSource_startConnection, _SnapshotSource_setUpConnectionListener;\nObject.defineProperty(Instance, \"__esModule\", { value: true });\nInstance.SnapshotSource = void 0;\n/* eslint-disable @typescript-eslint/no-non-null-assertion */\nconst base_1$1 = base;\nconst utils_1$1 = utils;\nconst connectionMap = new Map();\n/**\n * Enables configuring a SnapshotSource with custom getSnapshot and applySnapshot methods.\n *\n * @typeParam Snapshot Implementation-defined shape of an application snapshot.  Allows\n * custom snapshot implementations for legacy applications to define their own snapshot format.\n */\nclass SnapshotSource extends base_1$1.Base {\n    /**\n     * @internal\n     */\n    constructor(wire, id) {\n        super(wire);\n        _SnapshotSource_identity.set(this, void 0);\n        _SnapshotSource_getConnection.set(this, () => {\n            if (!connectionMap.has(this.identity.uuid)) {\n                connectionMap.set(this.identity.uuid, { eventFired: null, clientPromise: null });\n            }\n            return connectionMap.get(this.identity.uuid);\n        });\n        _SnapshotSource_getClient.set(this, () => {\n            if (!__classPrivateFieldGet$1(this, _SnapshotSource_getConnection, \"f\").call(this).clientPromise) {\n                __classPrivateFieldGet$1(this, _SnapshotSource_getConnection, \"f\").call(this).clientPromise = __classPrivateFieldGet$1(this, _SnapshotSource_startConnection, \"f\").call(this);\n            }\n            return __classPrivateFieldGet$1(this, _SnapshotSource_getConnection, \"f\").call(this).clientPromise;\n        });\n        _SnapshotSource_startConnection.set(this, async () => {\n            const channelName = (0, utils_1$1.getSnapshotSourceChannelName)(this.identity);\n            try {\n                if (!__classPrivateFieldGet$1(this, _SnapshotSource_getConnection, \"f\").call(this).eventFired) {\n                    await __classPrivateFieldGet$1(this, _SnapshotSource_setUpConnectionListener, \"f\").call(this);\n                }\n                const client = await this.fin.InterApplicationBus.Channel.connect(channelName, { wait: false });\n                client.onDisconnection(() => {\n                    __classPrivateFieldGet$1(this, _SnapshotSource_getConnection, \"f\").call(this).clientPromise = null;\n                    __classPrivateFieldGet$1(this, _SnapshotSource_getConnection, \"f\").call(this).eventFired = null;\n                });\n                return client;\n            }\n            catch (e) {\n                __classPrivateFieldGet$1(this, _SnapshotSource_getConnection, \"f\").call(this).clientPromise = null;\n                throw new Error(\"The targeted SnapshotSource is not currently initialized. Await this object's ready() method.\");\n            }\n        });\n        _SnapshotSource_setUpConnectionListener.set(this, async () => {\n            const channelName = (0, utils_1$1.getSnapshotSourceChannelName)(this.identity);\n            let resolve;\n            let reject;\n            const eventFired = new Promise((y, n) => {\n                resolve = y;\n                reject = n;\n            });\n            __classPrivateFieldGet$1(this, _SnapshotSource_getConnection, \"f\").call(this).eventFired = eventFired;\n            const listener = async (e) => {\n                try {\n                    if (e.channelName === channelName) {\n                        resolve();\n                        await this.fin.InterApplicationBus.Channel.removeListener('connected', listener);\n                    }\n                }\n                catch (err) {\n                    reject(err);\n                }\n            };\n            await this.fin.InterApplicationBus.Channel.on('connected', listener);\n        });\n        __classPrivateFieldSet$1(this, _SnapshotSource_identity, id, \"f\");\n    }\n    get identity() {\n        return __classPrivateFieldGet$1(this, _SnapshotSource_identity, \"f\");\n    }\n    /**\n     * Method to determine if the SnapshotSource has been initialized.\n     *\n     * @remarks Use when the parent application is starting up to ensure the SnapshotSource is able to accept and\n     * apply a snapshot using the {@link SnapshotSource#applySnapshot applySnapshot} method.\n     *\n     * @example\n     * ```js\n     * let snapshotSource = fin.SnapshotSource.wrapSync(fin.me);\n     *\n     * const snapshotProvider = {\n     *     async getSnapshot() { return 'foo' },\n     *     async applySnapshot(snapshot) {\n     *       console.log(snapshot);\n     *       return undefined;\n     *     }\n     * }\n     * await fin.SnapshotSource.init(snapshotProvider);\n     *\n     * try {\n     *   await snapshotSource.ready();\n     *   await snapshotSource.applySnapshot('foo');\n     * } catch (err) {\n     *   console.log(err)\n     * }\n     * ```\n     */\n    async ready() {\n        this.wire.sendAction('snapshot-source-ready').catch((e) => {\n            // don't expose, analytics-only call\n        });\n        // eslint-disable-next-line no-async-promise-executor\n        try {\n            // If getClient was already called before this, do we have a timing issue where the channel might have been created but we missed the event but this still fails?\n            await __classPrivateFieldGet$1(this, _SnapshotSource_getClient, \"f\").call(this);\n        }\n        catch (e) {\n            // it was not running.\n            await __classPrivateFieldGet$1(this, _SnapshotSource_getConnection, \"f\").call(this).eventFired;\n        }\n    }\n    /**\n     * Call the SnapshotSource's getSnapshot method defined by {@link SnapshotSource.SnapshotSourceModule#init init}.\n     *\n     */\n    async getSnapshot() {\n        this.wire.sendAction('snapshot-source-get-snapshot').catch((e) => {\n            // don't expose, analytics-only call\n        });\n        const client = await __classPrivateFieldGet$1(this, _SnapshotSource_getClient, \"f\").call(this);\n        const response = (await client.dispatch('get-snapshot'));\n        return (await response).snapshot;\n    }\n    /**\n     * Call the SnapshotSource's applySnapshot method defined by {@link SnapshotSource.SnapshotSourceModule#init init}.\n     *\n     */\n    async applySnapshot(snapshot) {\n        this.wire.sendAction('snapshot-source-apply-snapshot').catch((e) => {\n            // don't expose, analytics-only call\n        });\n        const client = await __classPrivateFieldGet$1(this, _SnapshotSource_getClient, \"f\").call(this);\n        return client.dispatch('apply-snapshot', { snapshot });\n    }\n}\nInstance.SnapshotSource = SnapshotSource;\n_SnapshotSource_identity = new WeakMap(), _SnapshotSource_getConnection = new WeakMap(), _SnapshotSource_getClient = new WeakMap(), _SnapshotSource_startConnection = new WeakMap(), _SnapshotSource_setUpConnectionListener = new WeakMap();\n\nObject.defineProperty(Factory, \"__esModule\", { value: true });\nFactory.SnapshotSourceModule = void 0;\nconst base_1 = base;\nconst Instance_1 = Instance;\nconst utils_1 = utils;\n/**\n * Static namespace for OpenFin API methods that interact with the {@link SnapshotSource} class, available under `fin.SnapshotSource`.\n */\nclass SnapshotSourceModule extends base_1.Base {\n    /**\n     * Initializes a SnapshotSource with the getSnapshot and applySnapshot methods defined.\n     *\n     * @typeParam Snapshot Implementation-defined shape of an application snapshot.  Allows\n     * custom snapshot implementations for legacy applications to define their own snapshot format.\n     *\n     * @example\n     * ```js\n     * const snapshotProvider = {\n     *     async getSnapshot() {\n     *       const bounds = await fin.me.getBounds();\n     *       return bounds;\n     *      },\n     *     async applySnapshot(snapshot) {\n     *       await fin.me.setBounds(snapshot);\n     *       return undefined;\n     *     }\n     * }\n     *\n     * await fin.SnapshotSource.init(snapshotProvider);\n     * ```\n     *\n     */\n    async init(provider) {\n        this.wire.sendAction('snapshot-source-init').catch((e) => {\n            // don't expose, analytics-only call\n        });\n        if (typeof provider !== 'object' ||\n            typeof provider.getSnapshot !== 'function' ||\n            typeof provider.applySnapshot !== 'function') {\n            throw new Error('you must pass in a valid SnapshotProvider');\n        }\n        const channel = await this.fin.InterApplicationBus.Channel.create((0, utils_1.getSnapshotSourceChannelName)(this.fin.me));\n        channel.register('get-snapshot', async () => {\n            const snapshot = await provider.getSnapshot();\n            return { snapshot };\n        });\n        channel.register('apply-snapshot', ({ snapshot }) => provider.applySnapshot(snapshot));\n    }\n    /**\n     * Synchronously returns a SnapshotSource object that represents the current SnapshotSource.\n     *\n     * @example\n     * ```js\n     * const snapshotSource = fin.SnapshotSource.wrapSync(fin.me);\n     * // Use wrapped instance's getSnapshot method, e.g.:\n     * const snapshot = await snapshotSource.getSnapshot();\n     * ```\n     */\n    wrapSync(identity) {\n        this.wire.sendAction('snapshot-source-wrap-sync').catch((e) => {\n            // don't expose, analytics-only call\n        });\n        return new Instance_1.SnapshotSource(this.wire, identity);\n    }\n    /**\n     * Asynchronously returns a SnapshotSource object that represents the current SnapshotSource.\n     *\n     * @example\n     * ```js\n     * const snapshotSource = await fin.SnapshotSource.wrap(fin.me);\n     * // Use wrapped instance's getSnapshot method, e.g.:\n     * const snapshot = await snapshotSource.getSnapshot();\n     * ```\n     */\n    async wrap(identity) {\n        this.wire.sendAction('snapshot-source-wrap').catch((e) => {\n            // don't expose, analytics-only call\n        });\n        return this.wrapSync(identity);\n    }\n}\nFactory.SnapshotSourceModule = SnapshotSourceModule;\n\n(function (exports) {\n\t/**\n\t * Entry points for the OpenFin `SnapshotSource` API (`fin.SnapshotSource`).\n\t *\n\t * * {@link SnapshotSourceModule} contains static members of the `SnapshotSource` API, accessible through `fin.SnapshotSource`.\n\t * * {@link SnapshotSource} describes an instance of an OpenFin SnapshotSource, e.g. as returned by `fin.SnapshotSource.wrap`.\n\t *\n\t * These are separate code entities, and are documented separately.  In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/32.114.76.10/index.html),\n\t * both of these were documented on the same page.\n\t *\n\t * @packageDocumentation\n\t */\n\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t    }\n\t    Object.defineProperty(o, k2, desc);\n\t}) : (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    o[k2] = m[k];\n\t}));\n\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t};\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t__exportStar(Factory, exports);\n\t__exportStar(Instance, exports); \n} (snapshotSource));\n\nObject.defineProperty(fin$2, \"__esModule\", { value: true });\nvar Fin_1 = fin$2.Fin = void 0;\nconst events_1$3 = require$$0;\n// Import from the file rather than the directory in case someone consuming types is using module resolution other than \"node\"\nconst index_1 = system;\nconst index_2 = requireWindow();\nconst index_3 = requireApplication();\nconst index_4 = interappbus;\nconst index_5 = clipboard;\nconst index_6 = externalApplication;\nconst index_7 = frame;\nconst index_8 = globalHotkey;\nconst index_9 = requireView();\nconst index_10 = platform;\nconst me_1$2 = me;\nconst interop_1 = requireInterop();\nconst snapshot_source_1 = snapshotSource;\n/**\n * @internal\n */\nclass Fin extends events_1$3.EventEmitter {\n    /**\n     * @internal\n     */\n    constructor(wire) {\n        super();\n        this.wire = wire;\n        this.System = new index_1.System(wire);\n        this.Window = new index_2._WindowModule(wire);\n        this.Application = new index_3.ApplicationModule(wire);\n        this.InterApplicationBus = new index_4.InterApplicationBus(wire);\n        this.Clipboard = new index_5.Clipboard(wire);\n        this.ExternalApplication = new index_6.ExternalApplicationModule(wire);\n        this.Frame = new index_7._FrameModule(wire);\n        this.GlobalHotkey = new index_8.GlobalHotkey(wire);\n        this.Platform = new index_10.PlatformModule(wire, this.InterApplicationBus.Channel);\n        this.View = new index_9.ViewModule(wire);\n        this.Interop = new interop_1.InteropModule(wire);\n        this.SnapshotSource = new snapshot_source_1.SnapshotSourceModule(wire);\n        wire.registerFin(this);\n        this.me = (0, me_1$2.getMe)(wire);\n        // Handle disconnect events\n        wire.on('disconnected', () => {\n            this.emit('disconnected');\n        });\n    }\n}\nFin_1 = fin$2.Fin = Fin;\n\nvar transport = {};\n\nvar wire = {};\n\nObject.defineProperty(wire, \"__esModule\", { value: true });\nwire.isInternalConnectConfig = wire.isPortDiscoveryConfig = wire.isNewConnectConfig = wire.isConfigWithReceiver = wire.isRemoteConfig = wire.isExistingConnectConfig = wire.isExternalConfig = void 0;\nfunction isExternalConfig(config) {\n    if (typeof config.manifestUrl === 'string') {\n        return true;\n    }\n    return false;\n}\nwire.isExternalConfig = isExternalConfig;\nfunction isExistingConnectConfig(config) {\n    return hasUuid(config) && typeof config.address === 'string';\n}\nwire.isExistingConnectConfig = isExistingConnectConfig;\nfunction isRemoteConfig(config) {\n    return isExistingConnectConfig(config) && typeof config.token === 'string';\n}\nwire.isRemoteConfig = isRemoteConfig;\nfunction isConfigWithReceiver(config) {\n    return typeof config.receiver === 'object' && isRemoteConfig({ ...config, address: '' });\n}\nwire.isConfigWithReceiver = isConfigWithReceiver;\nfunction hasUuid(config) {\n    return typeof config.uuid === 'string';\n}\nfunction hasRuntimeVersion(config) {\n    return config.runtime && typeof config.runtime.version === 'string';\n}\nfunction isNewConnectConfig(config) {\n    return hasUuid(config) && hasRuntimeVersion(config);\n}\nwire.isNewConnectConfig = isNewConnectConfig;\nfunction isPortDiscoveryConfig(config) {\n    return (isExternalConfig(config) && hasRuntimeVersion(config)) || isNewConnectConfig(config);\n}\nwire.isPortDiscoveryConfig = isPortDiscoveryConfig;\nfunction isInternalConnectConfig(config) {\n    return isExistingConnectConfig(config) || isNewConnectConfig(config);\n}\nwire.isInternalConnectConfig = isInternalConnectConfig;\n\nvar eventAggregator = {};\n\nvar emitterMap = {};\n\nObject.defineProperty(emitterMap, \"__esModule\", { value: true });\nemitterMap.EmitterMap = void 0;\nconst events_1$2 = require$$0;\nclass EmitterMap {\n    constructor() {\n        this.storage = new Map();\n    }\n    // eslint-disable-next-line class-methods-use-this\n    hashKeys(keys) {\n        const hashed = keys.map(normalizeString);\n        return hashed.join('/');\n    }\n    getOrCreate(keys) {\n        const hash = this.hashKeys(keys);\n        if (!this.storage.has(hash)) {\n            this.storage.set(hash, new events_1$2.EventEmitter());\n        }\n        // We set it above\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        return this.storage.get(hash);\n    }\n    has(keys) {\n        return this.storage.has(this.hashKeys(keys));\n    }\n    delete(keys) {\n        const hash = this.hashKeys(keys);\n        return this.storage.delete(hash);\n    }\n}\nemitterMap.EmitterMap = EmitterMap;\nfunction normalizeString(s) {\n    const b = Buffer.from(s);\n    return b.toString('base64');\n}\n\nObject.defineProperty(eventAggregator, \"__esModule\", { value: true });\nconst emitterMap_1 = emitterMap;\nfunction isEventMessage(message) {\n    return message.action === 'process-desktop-event';\n}\nfunction mapKeyFromEvent(event) {\n    const { topic } = event;\n    if (topic === 'frame' || topic === 'window' || topic === 'view') {\n        const { uuid, name } = event;\n        return [topic, uuid, name];\n    }\n    if (topic === 'application') {\n        const { uuid } = event;\n        return [topic, uuid];\n    }\n    return [topic];\n}\nclass EventAggregator extends emitterMap_1.EmitterMap {\n    constructor() {\n        super(...arguments);\n        this.dispatchEvent = (message) => {\n            if (isEventMessage(message)) {\n                const { payload } = message;\n                const accessor = mapKeyFromEvent(payload);\n                if (this.has(accessor)) {\n                    this.getOrCreate(accessor).emit(payload.type, payload);\n                    return true;\n                }\n            }\n            return false;\n        };\n    }\n}\neventAggregator.default = EventAggregator;\n\nvar __classPrivateFieldSet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar __classPrivateFieldGet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nvar _Transport_wire, _Transport_fin;\nObject.defineProperty(transport, \"__esModule\", { value: true });\nvar Transport_1 = transport.Transport = void 0;\nconst events_1$1 = require$$0;\nconst wire_1 = wire;\nconst transport_errors_1 = transportErrors;\nconst eventAggregator_1 = __importDefault(eventAggregator);\nconst me_1$1 = me;\nconst errors_1 = errors;\nclass Transport extends events_1$1.EventEmitter {\n    constructor(WireType, environment, config) {\n        super();\n        this.wireListeners = new Map();\n        this.topicRefMap = new Map();\n        this.eventAggregator = new eventAggregator_1.default();\n        this.messageHandlers = [this.eventAggregator.dispatchEvent];\n        _Transport_wire.set(this, void 0);\n        // Typing as unknown to avoid circular dependency, should not be used directly.\n        _Transport_fin.set(this, void 0);\n        this.connectSync = () => {\n            const wire = __classPrivateFieldGet(this, _Transport_wire, \"f\");\n            wire.connectSync();\n        };\n        // This function is only used in our tests.\n        this.getPort = () => {\n            const wire = __classPrivateFieldGet(this, _Transport_wire, \"f\");\n            return wire.getPort();\n        };\n        __classPrivateFieldSet(this, _Transport_wire, new WireType(this.onmessage.bind(this)), \"f\");\n        this.environment = environment;\n        this.sendRaw = __classPrivateFieldGet(this, _Transport_wire, \"f\").send.bind(__classPrivateFieldGet(this, _Transport_wire, \"f\"));\n        this.registerMessageHandler(this.handleMessage.bind(this));\n        __classPrivateFieldGet(this, _Transport_wire, \"f\").on('disconnected', () => {\n            for (const [, { handleNack }] of this.wireListeners) {\n                handleNack({ reason: 'Remote connection has closed' });\n            }\n            this.wireListeners.clear();\n            this.emit('disconnected');\n        });\n        const { uuid, name } = config;\n        const entityType = this.environment.getCurrentEntityType();\n        this.me = (0, me_1$1.getBaseMe)(entityType, uuid, name);\n    }\n    getFin() {\n        if (!__classPrivateFieldGet(this, _Transport_fin, \"f\")) {\n            throw new Error('No Fin object registered for this transport');\n        }\n        return __classPrivateFieldGet(this, _Transport_fin, \"f\");\n    }\n    registerFin(_fin) {\n        if (__classPrivateFieldGet(this, _Transport_fin, \"f\")) {\n            throw new Error('Fin object has already been registered for this transport');\n        }\n        __classPrivateFieldSet(this, _Transport_fin, _fin, \"f\");\n    }\n    shutdown() {\n        const wire = __classPrivateFieldGet(this, _Transport_wire, \"f\");\n        return wire.shutdown();\n    }\n    async connect(config) {\n        if ((0, wire_1.isConfigWithReceiver)(config)) {\n            await __classPrivateFieldGet(this, _Transport_wire, \"f\").connect(config.receiver);\n            return this.authorize(config);\n        }\n        if ((0, wire_1.isRemoteConfig)(config)) {\n            return this.connectRemote(config);\n        }\n        if ((0, wire_1.isExistingConnectConfig)(config)) {\n            return this.connectByPort(config);\n        }\n        if ((0, wire_1.isNewConnectConfig)(config)) {\n            const port = await this.environment.retrievePort(config);\n            return this.connectByPort({ ...config, address: `ws://localhost:${port}` });\n        }\n        return undefined;\n    }\n    async connectRemote(config) {\n        await __classPrivateFieldGet(this, _Transport_wire, \"f\").connect(new (this.environment.getWsConstructor())(config.address));\n        return this.authorize(config);\n    }\n    async connectByPort(config) {\n        const { address, uuid } = config;\n        const reqAuthPayload = { ...config, type: 'file-token' };\n        const wire = __classPrivateFieldGet(this, _Transport_wire, \"f\");\n        await wire.connect(new (this.environment.getWsConstructor())(config.address));\n        const requestExtAuthRet = await this.sendAction('request-external-authorization', {\n            uuid,\n            type: 'file-token'\n        }, true);\n        if (requestExtAuthRet.action !== 'external-authorization-response') {\n            throw new transport_errors_1.UnexpectedActionError(requestExtAuthRet.action);\n        }\n        await this.environment.writeToken(requestExtAuthRet.payload.file, requestExtAuthRet.payload.token);\n        return this.authorize(reqAuthPayload);\n    }\n    async authorize(reqAuthPayload) {\n        const requestAuthRet = await this.sendAction('request-authorization', reqAuthPayload, true);\n        if (requestAuthRet.action !== 'authorization-response') {\n            throw new transport_errors_1.UnexpectedActionError(requestAuthRet.action);\n        }\n        else if (requestAuthRet.payload.success !== true) {\n            throw new transport_errors_1.RuntimeError(requestAuthRet.payload);\n        }\n    }\n    sendAction(action, payload = {}, uncorrelated = false\n    // specialResponse type is only used for 'requestAuthorization'\n    ) {\n        // eslint-disable-next-line @typescript-eslint/no-empty-function\n        let cancel = () => { };\n        // We want the callsite from the caller of this function, not from here.\n        const callSites = transport_errors_1.RuntimeError.getCallSite(1);\n        const messageId = this.environment.getNextMessageId();\n        const prom = new Promise((resolve, reject) => {\n            cancel = reject;\n            const msg = {\n                action,\n                payload,\n                messageId\n            };\n            const wire = __classPrivateFieldGet(this, _Transport_wire, \"f\");\n            this.addWireListener(messageId, resolve, (payload) => this.nackHandler(payload, reject, callSites), uncorrelated);\n            return wire.send(msg).catch(reject);\n        });\n        return Object.assign(prom, { cancel, messageId });\n    }\n    nackHandler(payloadOrMessage, reject, callSites) {\n        if (typeof payloadOrMessage === 'string') {\n            // NOTE: this is for backwards compatibility to support plain string rejections\n            reject(payloadOrMessage);\n        }\n        else {\n            reject(new transport_errors_1.RuntimeError(payloadOrMessage, callSites));\n        }\n    }\n    ferryAction(origData) {\n        return new Promise((resolve, reject) => {\n            const id = this.environment.getNextMessageId();\n            origData.messageId = id;\n            const resolver = (data) => {\n                resolve(data.payload);\n            };\n            const wire = __classPrivateFieldGet(this, _Transport_wire, \"f\");\n            return wire\n                .send(origData)\n                .then(() => this.addWireListener(id, resolver, (payload) => this.nackHandler(payload, reject), false))\n                .catch(reject);\n        });\n    }\n    registerMessageHandler(handler) {\n        this.messageHandlers.push(handler);\n    }\n    addWireListener(id, resolve, handleNack, uncorrelated) {\n        if (uncorrelated) {\n            this.uncorrelatedListener = resolve;\n        }\n        else if (this.wireListeners.has(id)) {\n            handleNack({\n                reason: 'Duplicate handler id',\n                error: (0, errors_1.errorToPOJO)(new transport_errors_1.DuplicateCorrelationError(String(id)))\n            });\n        }\n        else {\n            this.wireListeners.set(id, { resolve, handleNack });\n        }\n        // Timeout and reject()?\n    }\n    // This method executes message handlers until the _one_ that handles the message (returns truthy) has run\n    onmessage(data) {\n        for (const h of this.messageHandlers) {\n            h.call(null, data);\n        }\n    }\n    handleMessage(data) {\n        const id = data.correlationId || NaN;\n        if (!('correlationId' in data)) {\n            if (this.uncorrelatedListener) {\n                this.uncorrelatedListener.call(null, data);\n            }\n            this.uncorrelatedListener = () => {\n                // empty block\n            };\n        }\n        else if (!this.wireListeners.has(id)) {\n            return false;\n        }\n        else {\n            // We just checked for existence above\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            const { resolve, handleNack } = this.wireListeners.get(id);\n            if (data.action !== 'ack') {\n                handleNack({ reason: 'Did not receive ack action', error: (0, errors_1.errorToPOJO)(new transport_errors_1.NoAckError(data.action)) });\n            }\n            else if (!('payload' in data)) {\n                // I'm not sure when this code would actually run, but passing in something that doeesn't have a reason to the runtimeerror constructor will not end well.\n                // @ts-expect-error\n                if (typeof data.reason === 'string') {\n                    handleNack(data);\n                }\n                else {\n                    console.warn('Received invalid response from core', data);\n                    handleNack({ reason: 'invalid response shape' });\n                }\n            }\n            else if (!data.payload.success) {\n                handleNack(data.payload);\n            }\n            else {\n                resolve.call(null, data);\n            }\n            this.wireListeners.delete(id);\n        }\n        return true;\n    }\n}\nTransport_1 = transport.Transport = Transport;\n_Transport_wire = new WeakMap(), _Transport_fin = new WeakMap();\n\nvar mockEnvironment = {};\n\nObject.defineProperty(mockEnvironment, \"__esModule\", { value: true });\nvar MockEnvironment_1 = mockEnvironment.MockEnvironment = void 0;\nconst me_1 = me;\nclass MockEnvironment {\n    constructor() {\n        this.type = 'other';\n        this.childViews = true;\n    }\n    getAdapterVersionSync() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    async getInteropInfo() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    getDefaultChannelOptions() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    getRtcPeer() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    layoutAllowedInContext(_fin) {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    initLayoutManager() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    applyLayoutSnapshot() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    async createLayout() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    async destroyLayout() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    async resolveLayout() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    initPlatform() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    observeBounds() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    writeToken(path, token) {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    retrievePort(config) {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    getNextMessageId() {\n        return `mock-message-id-${Math.random()}`;\n    }\n    getRandomId() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    createChildContent(options) {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    getWebWindow(identity) {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    getCurrentEntityIdentity() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    getCurrentEntityType() {\n        return 'unknown';\n    }\n    raiseEvent(eventName, eventArgs) {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    getUrl() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    whenReady() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    getWsConstructor() {\n        throw new Error('Method not implemented.');\n    }\n}\nMockEnvironment_1 = mockEnvironment.MockEnvironment = MockEnvironment;\n\nvar mockWire = {};\n\nObject.defineProperty(mockWire, \"__esModule\", { value: true });\nvar MockWire_1 = mockWire.MockWire = void 0;\n/* eslint-disable @typescript-eslint/no-unused-vars */\nconst events_1 = require$$0;\nclass MockWire extends events_1.EventEmitter {\n    connect() {\n        throw new Error('You are not running in OpenFin.');\n    }\n    connectSync() {\n        throw new Error('You are not running in OpenFin.');\n    }\n    send(data) {\n        throw new Error('You are not running in OpenFin.');\n    }\n    shutdown() {\n        throw new Error('You are not running in OpenFin.');\n    }\n    getPort() {\n        throw new Error('This transport has no port');\n    }\n    // eslint-disable-next-line no-useless-constructor\n    constructor() {\n        super();\n    }\n}\nMockWire_1 = mockWire.MockWire = MockWire;\n\nconst fin$1 = ((typeof window !== 'undefined' && window?.fin) ||\n    (() => {\n        const environment = new MockEnvironment_1();\n        const transport = new Transport_1(MockWire_1, environment, {\n            uuid: '',\n            name: ''\n        });\n        return new Fin_1(transport);\n    })());\n\nexports.OpenFin = OpenFin$1;\nexports.default = OpenFin$1;\nexports.fin = fin$1;\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar R = typeof Reflect === 'object' ? Reflect : null\nvar ReflectApply = R && typeof R.apply === 'function'\n  ? R.apply\n  : function ReflectApply(target, receiver, args) {\n    return Function.prototype.apply.call(target, receiver, args);\n  }\n\nvar ReflectOwnKeys\nif (R && typeof R.ownKeys === 'function') {\n  ReflectOwnKeys = R.ownKeys\n} else if (Object.getOwnPropertySymbols) {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target)\n      .concat(Object.getOwnPropertySymbols(target));\n  };\n} else {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target);\n  };\n}\n\nfunction ProcessEmitWarning(warning) {\n  if (console && console.warn) console.warn(warning);\n}\n\nvar NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {\n  return value !== value;\n}\n\nfunction EventEmitter() {\n  EventEmitter.init.call(this);\n}\nmodule.exports = EventEmitter;\nmodule.exports.once = once;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._eventsCount = 0;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nvar defaultMaxListeners = 10;\n\nfunction checkListener(listener) {\n  if (typeof listener !== 'function') {\n    throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n  }\n}\n\nObject.defineProperty(EventEmitter, 'defaultMaxListeners', {\n  enumerable: true,\n  get: function() {\n    return defaultMaxListeners;\n  },\n  set: function(arg) {\n    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {\n      throw new RangeError('The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received ' + arg + '.');\n    }\n    defaultMaxListeners = arg;\n  }\n});\n\nEventEmitter.init = function() {\n\n  if (this._events === undefined ||\n      this._events === Object.getPrototypeOf(this)._events) {\n    this._events = Object.create(null);\n    this._eventsCount = 0;\n  }\n\n  this._maxListeners = this._maxListeners || undefined;\n};\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {\n    throw new RangeError('The value of \"n\" is out of range. It must be a non-negative number. Received ' + n + '.');\n  }\n  this._maxListeners = n;\n  return this;\n};\n\nfunction _getMaxListeners(that) {\n  if (that._maxListeners === undefined)\n    return EventEmitter.defaultMaxListeners;\n  return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n  return _getMaxListeners(this);\n};\n\nEventEmitter.prototype.emit = function emit(type) {\n  var args = [];\n  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);\n  var doError = (type === 'error');\n\n  var events = this._events;\n  if (events !== undefined)\n    doError = (doError && events.error === undefined);\n  else if (!doError)\n    return false;\n\n  // If there is no 'error' event listener then throw.\n  if (doError) {\n    var er;\n    if (args.length > 0)\n      er = args[0];\n    if (er instanceof Error) {\n      // Note: The comments on the `throw` lines are intentional, they show\n      // up in Node's output if this results in an unhandled exception.\n      throw er; // Unhandled 'error' event\n    }\n    // At least give some kind of context to the user\n    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));\n    err.context = er;\n    throw err; // Unhandled 'error' event\n  }\n\n  var handler = events[type];\n\n  if (handler === undefined)\n    return false;\n\n  if (typeof handler === 'function') {\n    ReflectApply(handler, this, args);\n  } else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      ReflectApply(listeners[i], this, args);\n  }\n\n  return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n  var m;\n  var events;\n  var existing;\n\n  checkListener(listener);\n\n  events = target._events;\n  if (events === undefined) {\n    events = target._events = Object.create(null);\n    target._eventsCount = 0;\n  } else {\n    // To avoid recursion in the case that type === \"newListener\"! Before\n    // adding it to the listeners, first emit \"newListener\".\n    if (events.newListener !== undefined) {\n      target.emit('newListener', type,\n                  listener.listener ? listener.listener : listener);\n\n      // Re-assign `events` because a newListener handler could have caused the\n      // this._events to be assigned to a new object\n      events = target._events;\n    }\n    existing = events[type];\n  }\n\n  if (existing === undefined) {\n    // Optimize the case of one listener. Don't need the extra array object.\n    existing = events[type] = listener;\n    ++target._eventsCount;\n  } else {\n    if (typeof existing === 'function') {\n      // Adding the second element, need to change to array.\n      existing = events[type] =\n        prepend ? [listener, existing] : [existing, listener];\n      // If we've already got an array, just append.\n    } else if (prepend) {\n      existing.unshift(listener);\n    } else {\n      existing.push(listener);\n    }\n\n    // Check for listener leak\n    m = _getMaxListeners(target);\n    if (m > 0 && existing.length > m && !existing.warned) {\n      existing.warned = true;\n      // No error code for this since it is a Warning\n      // eslint-disable-next-line no-restricted-syntax\n      var w = new Error('Possible EventEmitter memory leak detected. ' +\n                          existing.length + ' ' + String(type) + ' listeners ' +\n                          'added. Use emitter.setMaxListeners() to ' +\n                          'increase limit');\n      w.name = 'MaxListenersExceededWarning';\n      w.emitter = target;\n      w.type = type;\n      w.count = existing.length;\n      ProcessEmitWarning(w);\n    }\n  }\n\n  return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n  return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener =\n    function prependListener(type, listener) {\n      return _addListener(this, type, listener, true);\n    };\n\nfunction onceWrapper() {\n  if (!this.fired) {\n    this.target.removeListener(this.type, this.wrapFn);\n    this.fired = true;\n    if (arguments.length === 0)\n      return this.listener.call(this.target);\n    return this.listener.apply(this.target, arguments);\n  }\n}\n\nfunction _onceWrap(target, type, listener) {\n  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n  var wrapped = onceWrapper.bind(state);\n  wrapped.listener = listener;\n  state.wrapFn = wrapped;\n  return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n  checkListener(listener);\n  this.on(type, _onceWrap(this, type, listener));\n  return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n    function prependOnceListener(type, listener) {\n      checkListener(listener);\n      this.prependListener(type, _onceWrap(this, type, listener));\n      return this;\n    };\n\n// Emits a 'removeListener' event if and only if the listener was removed.\nEventEmitter.prototype.removeListener =\n    function removeListener(type, listener) {\n      var list, events, position, i, originalListener;\n\n      checkListener(listener);\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      list = events[type];\n      if (list === undefined)\n        return this;\n\n      if (list === listener || list.listener === listener) {\n        if (--this._eventsCount === 0)\n          this._events = Object.create(null);\n        else {\n          delete events[type];\n          if (events.removeListener)\n            this.emit('removeListener', type, list.listener || listener);\n        }\n      } else if (typeof list !== 'function') {\n        position = -1;\n\n        for (i = list.length - 1; i >= 0; i--) {\n          if (list[i] === listener || list[i].listener === listener) {\n            originalListener = list[i].listener;\n            position = i;\n            break;\n          }\n        }\n\n        if (position < 0)\n          return this;\n\n        if (position === 0)\n          list.shift();\n        else {\n          spliceOne(list, position);\n        }\n\n        if (list.length === 1)\n          events[type] = list[0];\n\n        if (events.removeListener !== undefined)\n          this.emit('removeListener', type, originalListener || listener);\n      }\n\n      return this;\n    };\n\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\n\nEventEmitter.prototype.removeAllListeners =\n    function removeAllListeners(type) {\n      var listeners, events, i;\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      // not listening for removeListener, no need to emit\n      if (events.removeListener === undefined) {\n        if (arguments.length === 0) {\n          this._events = Object.create(null);\n          this._eventsCount = 0;\n        } else if (events[type] !== undefined) {\n          if (--this._eventsCount === 0)\n            this._events = Object.create(null);\n          else\n            delete events[type];\n        }\n        return this;\n      }\n\n      // emit removeListener for all listeners on all events\n      if (arguments.length === 0) {\n        var keys = Object.keys(events);\n        var key;\n        for (i = 0; i < keys.length; ++i) {\n          key = keys[i];\n          if (key === 'removeListener') continue;\n          this.removeAllListeners(key);\n        }\n        this.removeAllListeners('removeListener');\n        this._events = Object.create(null);\n        this._eventsCount = 0;\n        return this;\n      }\n\n      listeners = events[type];\n\n      if (typeof listeners === 'function') {\n        this.removeListener(type, listeners);\n      } else if (listeners !== undefined) {\n        // LIFO order\n        for (i = listeners.length - 1; i >= 0; i--) {\n          this.removeListener(type, listeners[i]);\n        }\n      }\n\n      return this;\n    };\n\nfunction _listeners(target, type, unwrap) {\n  var events = target._events;\n\n  if (events === undefined)\n    return [];\n\n  var evlistener = events[type];\n  if (evlistener === undefined)\n    return [];\n\n  if (typeof evlistener === 'function')\n    return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n\n  return unwrap ?\n    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n  return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n  return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  if (typeof emitter.listenerCount === 'function') {\n    return emitter.listenerCount(type);\n  } else {\n    return listenerCount.call(emitter, type);\n  }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n  var events = this._events;\n\n  if (events !== undefined) {\n    var evlistener = events[type];\n\n    if (typeof evlistener === 'function') {\n      return 1;\n    } else if (evlistener !== undefined) {\n      return evlistener.length;\n    }\n  }\n\n  return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];\n};\n\nfunction arrayClone(arr, n) {\n  var copy = new Array(n);\n  for (var i = 0; i < n; ++i)\n    copy[i] = arr[i];\n  return copy;\n}\n\nfunction spliceOne(list, index) {\n  for (; index + 1 < list.length; index++)\n    list[index] = list[index + 1];\n  list.pop();\n}\n\nfunction unwrapListeners(arr) {\n  var ret = new Array(arr.length);\n  for (var i = 0; i < ret.length; ++i) {\n    ret[i] = arr[i].listener || arr[i];\n  }\n  return ret;\n}\n\nfunction once(emitter, name) {\n  return new Promise(function (resolve, reject) {\n    function errorListener(err) {\n      emitter.removeListener(name, resolver);\n      reject(err);\n    }\n\n    function resolver() {\n      if (typeof emitter.removeListener === 'function') {\n        emitter.removeListener('error', errorListener);\n      }\n      resolve([].slice.call(arguments));\n    };\n\n    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });\n    if (name !== 'error') {\n      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });\n    }\n  });\n}\n\nfunction addErrorHandlerIfEventEmitter(emitter, handler, flags) {\n  if (typeof emitter.on === 'function') {\n    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);\n  }\n}\n\nfunction eventTargetAgnosticAddListener(emitter, name, listener, flags) {\n  if (typeof emitter.on === 'function') {\n    if (flags.once) {\n      emitter.once(name, listener);\n    } else {\n      emitter.on(name, listener);\n    }\n  } else if (typeof emitter.addEventListener === 'function') {\n    // EventTarget does not have `error` event semantics like Node\n    // EventEmitters, we do not listen for `error` events here.\n    emitter.addEventListener(name, function wrapListener(arg) {\n      // IE does not have builtin `{ once: true }` support so we\n      // have to do it manually.\n      if (flags.once) {\n        emitter.removeEventListener(name, wrapListener);\n      }\n      listener(arg);\n    });\n  } else {\n    throw new TypeError('The \"emitter\" argument must be of type EventEmitter. Received type ' + typeof emitter);\n  }\n}\n","var getNative = require('./_getNative'),\n    root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar DataView = getNative(root, 'DataView');\n\nmodule.exports = DataView;\n","var hashClear = require('./_hashClear'),\n    hashDelete = require('./_hashDelete'),\n    hashGet = require('./_hashGet'),\n    hashHas = require('./_hashHas'),\n    hashSet = require('./_hashSet');\n\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Hash(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\nmodule.exports = Hash;\n","var listCacheClear = require('./_listCacheClear'),\n    listCacheDelete = require('./_listCacheDelete'),\n    listCacheGet = require('./_listCacheGet'),\n    listCacheHas = require('./_listCacheHas'),\n    listCacheSet = require('./_listCacheSet');\n\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction ListCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\nmodule.exports = ListCache;\n","var getNative = require('./_getNative'),\n    root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar Map = getNative(root, 'Map');\n\nmodule.exports = Map;\n","var mapCacheClear = require('./_mapCacheClear'),\n    mapCacheDelete = require('./_mapCacheDelete'),\n    mapCacheGet = require('./_mapCacheGet'),\n    mapCacheHas = require('./_mapCacheHas'),\n    mapCacheSet = require('./_mapCacheSet');\n\n/**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction MapCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\nmodule.exports = MapCache;\n","var getNative = require('./_getNative'),\n    root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar Promise = getNative(root, 'Promise');\n\nmodule.exports = Promise;\n","var getNative = require('./_getNative'),\n    root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar Set = getNative(root, 'Set');\n\nmodule.exports = Set;\n","var MapCache = require('./_MapCache'),\n    setCacheAdd = require('./_setCacheAdd'),\n    setCacheHas = require('./_setCacheHas');\n\n/**\n *\n * Creates an array cache object to store unique values.\n *\n * @private\n * @constructor\n * @param {Array} [values] The values to cache.\n */\nfunction SetCache(values) {\n  var index = -1,\n      length = values == null ? 0 : values.length;\n\n  this.__data__ = new MapCache;\n  while (++index < length) {\n    this.add(values[index]);\n  }\n}\n\n// Add methods to `SetCache`.\nSetCache.prototype.add = SetCache.prototype.push = setCacheAdd;\nSetCache.prototype.has = setCacheHas;\n\nmodule.exports = SetCache;\n","var ListCache = require('./_ListCache'),\n    stackClear = require('./_stackClear'),\n    stackDelete = require('./_stackDelete'),\n    stackGet = require('./_stackGet'),\n    stackHas = require('./_stackHas'),\n    stackSet = require('./_stackSet');\n\n/**\n * Creates a stack cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Stack(entries) {\n  var data = this.__data__ = new ListCache(entries);\n  this.size = data.size;\n}\n\n// Add methods to `Stack`.\nStack.prototype.clear = stackClear;\nStack.prototype['delete'] = stackDelete;\nStack.prototype.get = stackGet;\nStack.prototype.has = stackHas;\nStack.prototype.set = stackSet;\n\nmodule.exports = Stack;\n","var root = require('./_root');\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nmodule.exports = Symbol;\n","var root = require('./_root');\n\n/** Built-in value references. */\nvar Uint8Array = root.Uint8Array;\n\nmodule.exports = Uint8Array;\n","var getNative = require('./_getNative'),\n    root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar WeakMap = getNative(root, 'WeakMap');\n\nmodule.exports = WeakMap;\n","/**\n * A specialized version of `_.forEach` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns `array`.\n */\nfunction arrayEach(array, iteratee) {\n  var index = -1,\n      length = array == null ? 0 : array.length;\n\n  while (++index < length) {\n    if (iteratee(array[index], index, array) === false) {\n      break;\n    }\n  }\n  return array;\n}\n\nmodule.exports = arrayEach;\n","/**\n * A specialized version of `_.filter` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {Array} Returns the new filtered array.\n */\nfunction arrayFilter(array, predicate) {\n  var index = -1,\n      length = array == null ? 0 : array.length,\n      resIndex = 0,\n      result = [];\n\n  while (++index < length) {\n    var value = array[index];\n    if (predicate(value, index, array)) {\n      result[resIndex++] = value;\n    }\n  }\n  return result;\n}\n\nmodule.exports = arrayFilter;\n","var baseTimes = require('./_baseTimes'),\n    isArguments = require('./isArguments'),\n    isArray = require('./isArray'),\n    isBuffer = require('./isBuffer'),\n    isIndex = require('./_isIndex'),\n    isTypedArray = require('./isTypedArray');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n  var isArr = isArray(value),\n      isArg = !isArr && isArguments(value),\n      isBuff = !isArr && !isArg && isBuffer(value),\n      isType = !isArr && !isArg && !isBuff && isTypedArray(value),\n      skipIndexes = isArr || isArg || isBuff || isType,\n      result = skipIndexes ? baseTimes(value.length, String) : [],\n      length = result.length;\n\n  for (var key in value) {\n    if ((inherited || hasOwnProperty.call(value, key)) &&\n        !(skipIndexes && (\n           // Safari 9 has enumerable `arguments.length` in strict mode.\n           key == 'length' ||\n           // Node.js 0.10 has enumerable non-index properties on buffers.\n           (isBuff && (key == 'offset' || key == 'parent')) ||\n           // PhantomJS 2 has enumerable non-index properties on typed arrays.\n           (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||\n           // Skip index properties.\n           isIndex(key, length)\n        ))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nmodule.exports = arrayLikeKeys;\n","/**\n * Appends the elements of `values` to `array`.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to append.\n * @returns {Array} Returns `array`.\n */\nfunction arrayPush(array, values) {\n  var index = -1,\n      length = values.length,\n      offset = array.length;\n\n  while (++index < length) {\n    array[offset + index] = values[index];\n  }\n  return array;\n}\n\nmodule.exports = arrayPush;\n","/**\n * A specialized version of `_.some` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {boolean} Returns `true` if any element passes the predicate check,\n *  else `false`.\n */\nfunction arraySome(array, predicate) {\n  var index = -1,\n      length = array == null ? 0 : array.length;\n\n  while (++index < length) {\n    if (predicate(array[index], index, array)) {\n      return true;\n    }\n  }\n  return false;\n}\n\nmodule.exports = arraySome;\n","var baseAssignValue = require('./_baseAssignValue'),\n    eq = require('./eq');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Assigns `value` to `key` of `object` if the existing value is not equivalent\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignValue(object, key, value) {\n  var objValue = object[key];\n  if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||\n      (value === undefined && !(key in object))) {\n    baseAssignValue(object, key, value);\n  }\n}\n\nmodule.exports = assignValue;\n","var eq = require('./eq');\n\n/**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction assocIndexOf(array, key) {\n  var length = array.length;\n  while (length--) {\n    if (eq(array[length][0], key)) {\n      return length;\n    }\n  }\n  return -1;\n}\n\nmodule.exports = assocIndexOf;\n","var copyObject = require('./_copyObject'),\n    keys = require('./keys');\n\n/**\n * The base implementation of `_.assign` without support for multiple sources\n * or `customizer` functions.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @returns {Object} Returns `object`.\n */\nfunction baseAssign(object, source) {\n  return object && copyObject(source, keys(source), object);\n}\n\nmodule.exports = baseAssign;\n","var copyObject = require('./_copyObject'),\n    keysIn = require('./keysIn');\n\n/**\n * The base implementation of `_.assignIn` without support for multiple sources\n * or `customizer` functions.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @returns {Object} Returns `object`.\n */\nfunction baseAssignIn(object, source) {\n  return object && copyObject(source, keysIn(source), object);\n}\n\nmodule.exports = baseAssignIn;\n","var defineProperty = require('./_defineProperty');\n\n/**\n * The base implementation of `assignValue` and `assignMergeValue` without\n * value checks.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction baseAssignValue(object, key, value) {\n  if (key == '__proto__' && defineProperty) {\n    defineProperty(object, key, {\n      'configurable': true,\n      'enumerable': true,\n      'value': value,\n      'writable': true\n    });\n  } else {\n    object[key] = value;\n  }\n}\n\nmodule.exports = baseAssignValue;\n","var Stack = require('./_Stack'),\n    arrayEach = require('./_arrayEach'),\n    assignValue = require('./_assignValue'),\n    baseAssign = require('./_baseAssign'),\n    baseAssignIn = require('./_baseAssignIn'),\n    cloneBuffer = require('./_cloneBuffer'),\n    copyArray = require('./_copyArray'),\n    copySymbols = require('./_copySymbols'),\n    copySymbolsIn = require('./_copySymbolsIn'),\n    getAllKeys = require('./_getAllKeys'),\n    getAllKeysIn = require('./_getAllKeysIn'),\n    getTag = require('./_getTag'),\n    initCloneArray = require('./_initCloneArray'),\n    initCloneByTag = require('./_initCloneByTag'),\n    initCloneObject = require('./_initCloneObject'),\n    isArray = require('./isArray'),\n    isBuffer = require('./isBuffer'),\n    isMap = require('./isMap'),\n    isObject = require('./isObject'),\n    isSet = require('./isSet'),\n    keys = require('./keys'),\n    keysIn = require('./keysIn');\n\n/** Used to compose bitmasks for cloning. */\nvar CLONE_DEEP_FLAG = 1,\n    CLONE_FLAT_FLAG = 2,\n    CLONE_SYMBOLS_FLAG = 4;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    objectTag = '[object Object]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    symbolTag = '[object Symbol]',\n    weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]',\n    float32Tag = '[object Float32Array]',\n    float64Tag = '[object Float64Array]',\n    int8Tag = '[object Int8Array]',\n    int16Tag = '[object Int16Array]',\n    int32Tag = '[object Int32Array]',\n    uint8Tag = '[object Uint8Array]',\n    uint8ClampedTag = '[object Uint8ClampedArray]',\n    uint16Tag = '[object Uint16Array]',\n    uint32Tag = '[object Uint32Array]';\n\n/** Used to identify `toStringTag` values supported by `_.clone`. */\nvar cloneableTags = {};\ncloneableTags[argsTag] = cloneableTags[arrayTag] =\ncloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =\ncloneableTags[boolTag] = cloneableTags[dateTag] =\ncloneableTags[float32Tag] = cloneableTags[float64Tag] =\ncloneableTags[int8Tag] = cloneableTags[int16Tag] =\ncloneableTags[int32Tag] = cloneableTags[mapTag] =\ncloneableTags[numberTag] = cloneableTags[objectTag] =\ncloneableTags[regexpTag] = cloneableTags[setTag] =\ncloneableTags[stringTag] = cloneableTags[symbolTag] =\ncloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =\ncloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;\ncloneableTags[errorTag] = cloneableTags[funcTag] =\ncloneableTags[weakMapTag] = false;\n\n/**\n * The base implementation of `_.clone` and `_.cloneDeep` which tracks\n * traversed objects.\n *\n * @private\n * @param {*} value The value to clone.\n * @param {boolean} bitmask The bitmask flags.\n *  1 - Deep clone\n *  2 - Flatten inherited properties\n *  4 - Clone symbols\n * @param {Function} [customizer] The function to customize cloning.\n * @param {string} [key] The key of `value`.\n * @param {Object} [object] The parent object of `value`.\n * @param {Object} [stack] Tracks traversed objects and their clone counterparts.\n * @returns {*} Returns the cloned value.\n */\nfunction baseClone(value, bitmask, customizer, key, object, stack) {\n  var result,\n      isDeep = bitmask & CLONE_DEEP_FLAG,\n      isFlat = bitmask & CLONE_FLAT_FLAG,\n      isFull = bitmask & CLONE_SYMBOLS_FLAG;\n\n  if (customizer) {\n    result = object ? customizer(value, key, object, stack) : customizer(value);\n  }\n  if (result !== undefined) {\n    return result;\n  }\n  if (!isObject(value)) {\n    return value;\n  }\n  var isArr = isArray(value);\n  if (isArr) {\n    result = initCloneArray(value);\n    if (!isDeep) {\n      return copyArray(value, result);\n    }\n  } else {\n    var tag = getTag(value),\n        isFunc = tag == funcTag || tag == genTag;\n\n    if (isBuffer(value)) {\n      return cloneBuffer(value, isDeep);\n    }\n    if (tag == objectTag || tag == argsTag || (isFunc && !object)) {\n      result = (isFlat || isFunc) ? {} : initCloneObject(value);\n      if (!isDeep) {\n        return isFlat\n          ? copySymbolsIn(value, baseAssignIn(result, value))\n          : copySymbols(value, baseAssign(result, value));\n      }\n    } else {\n      if (!cloneableTags[tag]) {\n        return object ? value : {};\n      }\n      result = initCloneByTag(value, tag, isDeep);\n    }\n  }\n  // Check for circular references and return its corresponding clone.\n  stack || (stack = new Stack);\n  var stacked = stack.get(value);\n  if (stacked) {\n    return stacked;\n  }\n  stack.set(value, result);\n\n  if (isSet(value)) {\n    value.forEach(function(subValue) {\n      result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));\n    });\n  } else if (isMap(value)) {\n    value.forEach(function(subValue, key) {\n      result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));\n    });\n  }\n\n  var keysFunc = isFull\n    ? (isFlat ? getAllKeysIn : getAllKeys)\n    : (isFlat ? keysIn : keys);\n\n  var props = isArr ? undefined : keysFunc(value);\n  arrayEach(props || value, function(subValue, key) {\n    if (props) {\n      key = subValue;\n      subValue = value[key];\n    }\n    // Recursively populate clone (susceptible to call stack limits).\n    assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));\n  });\n  return result;\n}\n\nmodule.exports = baseClone;\n","var isObject = require('./isObject');\n\n/** Built-in value references. */\nvar objectCreate = Object.create;\n\n/**\n * The base implementation of `_.create` without support for assigning\n * properties to the created object.\n *\n * @private\n * @param {Object} proto The object to inherit from.\n * @returns {Object} Returns the new object.\n */\nvar baseCreate = (function() {\n  function object() {}\n  return function(proto) {\n    if (!isObject(proto)) {\n      return {};\n    }\n    if (objectCreate) {\n      return objectCreate(proto);\n    }\n    object.prototype = proto;\n    var result = new object;\n    object.prototype = undefined;\n    return result;\n  };\n}());\n\nmodule.exports = baseCreate;\n","var arrayPush = require('./_arrayPush'),\n    isArray = require('./isArray');\n\n/**\n * The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @param {Function} symbolsFunc The function to get the symbols of `object`.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction baseGetAllKeys(object, keysFunc, symbolsFunc) {\n  var result = keysFunc(object);\n  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n}\n\nmodule.exports = baseGetAllKeys;\n","var Symbol = require('./_Symbol'),\n    getRawTag = require('./_getRawTag'),\n    objectToString = require('./_objectToString');\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n    undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag && symToStringTag in Object(value))\n    ? getRawTag(value)\n    : objectToString(value);\n}\n\nmodule.exports = baseGetTag;\n","var baseGetTag = require('./_baseGetTag'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]';\n\n/**\n * The base implementation of `_.isArguments`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n */\nfunction baseIsArguments(value) {\n  return isObjectLike(value) && baseGetTag(value) == argsTag;\n}\n\nmodule.exports = baseIsArguments;\n","var baseIsEqualDeep = require('./_baseIsEqualDeep'),\n    isObjectLike = require('./isObjectLike');\n\n/**\n * The base implementation of `_.isEqual` which supports partial comparisons\n * and tracks traversed objects.\n *\n * @private\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @param {boolean} bitmask The bitmask flags.\n *  1 - Unordered comparison\n *  2 - Partial comparison\n * @param {Function} [customizer] The function to customize comparisons.\n * @param {Object} [stack] Tracks traversed `value` and `other` objects.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n */\nfunction baseIsEqual(value, other, bitmask, customizer, stack) {\n  if (value === other) {\n    return true;\n  }\n  if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {\n    return value !== value && other !== other;\n  }\n  return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);\n}\n\nmodule.exports = baseIsEqual;\n","var Stack = require('./_Stack'),\n    equalArrays = require('./_equalArrays'),\n    equalByTag = require('./_equalByTag'),\n    equalObjects = require('./_equalObjects'),\n    getTag = require('./_getTag'),\n    isArray = require('./isArray'),\n    isBuffer = require('./isBuffer'),\n    isTypedArray = require('./isTypedArray');\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    objectTag = '[object Object]';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * A specialized version of `baseIsEqual` for arrays and objects which performs\n * deep comparisons and tracks traversed objects enabling objects with circular\n * references to be compared.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} [stack] Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {\n  var objIsArr = isArray(object),\n      othIsArr = isArray(other),\n      objTag = objIsArr ? arrayTag : getTag(object),\n      othTag = othIsArr ? arrayTag : getTag(other);\n\n  objTag = objTag == argsTag ? objectTag : objTag;\n  othTag = othTag == argsTag ? objectTag : othTag;\n\n  var objIsObj = objTag == objectTag,\n      othIsObj = othTag == objectTag,\n      isSameTag = objTag == othTag;\n\n  if (isSameTag && isBuffer(object)) {\n    if (!isBuffer(other)) {\n      return false;\n    }\n    objIsArr = true;\n    objIsObj = false;\n  }\n  if (isSameTag && !objIsObj) {\n    stack || (stack = new Stack);\n    return (objIsArr || isTypedArray(object))\n      ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)\n      : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);\n  }\n  if (!(bitmask & COMPARE_PARTIAL_FLAG)) {\n    var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),\n        othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');\n\n    if (objIsWrapped || othIsWrapped) {\n      var objUnwrapped = objIsWrapped ? object.value() : object,\n          othUnwrapped = othIsWrapped ? other.value() : other;\n\n      stack || (stack = new Stack);\n      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);\n    }\n  }\n  if (!isSameTag) {\n    return false;\n  }\n  stack || (stack = new Stack);\n  return equalObjects(object, other, bitmask, customizer, equalFunc, stack);\n}\n\nmodule.exports = baseIsEqualDeep;\n","var getTag = require('./_getTag'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar mapTag = '[object Map]';\n\n/**\n * The base implementation of `_.isMap` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a map, else `false`.\n */\nfunction baseIsMap(value) {\n  return isObjectLike(value) && getTag(value) == mapTag;\n}\n\nmodule.exports = baseIsMap;\n","var isFunction = require('./isFunction'),\n    isMasked = require('./_isMasked'),\n    isObject = require('./isObject'),\n    toSource = require('./_toSource');\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n    objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n  .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n *  else `false`.\n */\nfunction baseIsNative(value) {\n  if (!isObject(value) || isMasked(value)) {\n    return false;\n  }\n  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n  return pattern.test(toSource(value));\n}\n\nmodule.exports = baseIsNative;\n","var getTag = require('./_getTag'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar setTag = '[object Set]';\n\n/**\n * The base implementation of `_.isSet` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a set, else `false`.\n */\nfunction baseIsSet(value) {\n  return isObjectLike(value) && getTag(value) == setTag;\n}\n\nmodule.exports = baseIsSet;\n","var baseGetTag = require('./_baseGetTag'),\n    isLength = require('./isLength'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    funcTag = '[object Function]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    objectTag = '[object Object]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]',\n    float32Tag = '[object Float32Array]',\n    float64Tag = '[object Float64Array]',\n    int8Tag = '[object Int8Array]',\n    int16Tag = '[object Int16Array]',\n    int32Tag = '[object Int32Array]',\n    uint8Tag = '[object Uint8Array]',\n    uint8ClampedTag = '[object Uint8ClampedArray]',\n    uint16Tag = '[object Uint16Array]',\n    uint32Tag = '[object Uint32Array]';\n\n/** Used to identify `toStringTag` values of typed arrays. */\nvar typedArrayTags = {};\ntypedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\ntypedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\ntypedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\ntypedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\ntypedArrayTags[uint32Tag] = true;\ntypedArrayTags[argsTag] = typedArrayTags[arrayTag] =\ntypedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\ntypedArrayTags[dataViewTag] = typedArrayTags[dateTag] =\ntypedArrayTags[errorTag] = typedArrayTags[funcTag] =\ntypedArrayTags[mapTag] = typedArrayTags[numberTag] =\ntypedArrayTags[objectTag] = typedArrayTags[regexpTag] =\ntypedArrayTags[setTag] = typedArrayTags[stringTag] =\ntypedArrayTags[weakMapTag] = false;\n\n/**\n * The base implementation of `_.isTypedArray` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n */\nfunction baseIsTypedArray(value) {\n  return isObjectLike(value) &&\n    isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n}\n\nmodule.exports = baseIsTypedArray;\n","var isPrototype = require('./_isPrototype'),\n    nativeKeys = require('./_nativeKeys');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeys(object) {\n  if (!isPrototype(object)) {\n    return nativeKeys(object);\n  }\n  var result = [];\n  for (var key in Object(object)) {\n    if (hasOwnProperty.call(object, key) && key != 'constructor') {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nmodule.exports = baseKeys;\n","var isObject = require('./isObject'),\n    isPrototype = require('./_isPrototype'),\n    nativeKeysIn = require('./_nativeKeysIn');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeysIn(object) {\n  if (!isObject(object)) {\n    return nativeKeysIn(object);\n  }\n  var isProto = isPrototype(object),\n      result = [];\n\n  for (var key in object) {\n    if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nmodule.exports = baseKeysIn;\n","/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n  var index = -1,\n      result = Array(n);\n\n  while (++index < n) {\n    result[index] = iteratee(index);\n  }\n  return result;\n}\n\nmodule.exports = baseTimes;\n","/**\n * The base implementation of `_.unary` without support for storing metadata.\n *\n * @private\n * @param {Function} func The function to cap arguments for.\n * @returns {Function} Returns the new capped function.\n */\nfunction baseUnary(func) {\n  return function(value) {\n    return func(value);\n  };\n}\n\nmodule.exports = baseUnary;\n","/**\n * Checks if a `cache` value for `key` exists.\n *\n * @private\n * @param {Object} cache The cache to query.\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction cacheHas(cache, key) {\n  return cache.has(key);\n}\n\nmodule.exports = cacheHas;\n","var Uint8Array = require('./_Uint8Array');\n\n/**\n * Creates a clone of `arrayBuffer`.\n *\n * @private\n * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n * @returns {ArrayBuffer} Returns the cloned array buffer.\n */\nfunction cloneArrayBuffer(arrayBuffer) {\n  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n  new Uint8Array(result).set(new Uint8Array(arrayBuffer));\n  return result;\n}\n\nmodule.exports = cloneArrayBuffer;\n","var root = require('./_root');\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined,\n    allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined;\n\n/**\n * Creates a clone of  `buffer`.\n *\n * @private\n * @param {Buffer} buffer The buffer to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Buffer} Returns the cloned buffer.\n */\nfunction cloneBuffer(buffer, isDeep) {\n  if (isDeep) {\n    return buffer.slice();\n  }\n  var length = buffer.length,\n      result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);\n\n  buffer.copy(result);\n  return result;\n}\n\nmodule.exports = cloneBuffer;\n","var cloneArrayBuffer = require('./_cloneArrayBuffer');\n\n/**\n * Creates a clone of `dataView`.\n *\n * @private\n * @param {Object} dataView The data view to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned data view.\n */\nfunction cloneDataView(dataView, isDeep) {\n  var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;\n  return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);\n}\n\nmodule.exports = cloneDataView;\n","/** Used to match `RegExp` flags from their coerced string values. */\nvar reFlags = /\\w*$/;\n\n/**\n * Creates a clone of `regexp`.\n *\n * @private\n * @param {Object} regexp The regexp to clone.\n * @returns {Object} Returns the cloned regexp.\n */\nfunction cloneRegExp(regexp) {\n  var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));\n  result.lastIndex = regexp.lastIndex;\n  return result;\n}\n\nmodule.exports = cloneRegExp;\n","var Symbol = require('./_Symbol');\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;\n\n/**\n * Creates a clone of the `symbol` object.\n *\n * @private\n * @param {Object} symbol The symbol object to clone.\n * @returns {Object} Returns the cloned symbol object.\n */\nfunction cloneSymbol(symbol) {\n  return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};\n}\n\nmodule.exports = cloneSymbol;\n","var cloneArrayBuffer = require('./_cloneArrayBuffer');\n\n/**\n * Creates a clone of `typedArray`.\n *\n * @private\n * @param {Object} typedArray The typed array to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned typed array.\n */\nfunction cloneTypedArray(typedArray, isDeep) {\n  var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n}\n\nmodule.exports = cloneTypedArray;\n","/**\n * Copies the values of `source` to `array`.\n *\n * @private\n * @param {Array} source The array to copy values from.\n * @param {Array} [array=[]] The array to copy values to.\n * @returns {Array} Returns `array`.\n */\nfunction copyArray(source, array) {\n  var index = -1,\n      length = source.length;\n\n  array || (array = Array(length));\n  while (++index < length) {\n    array[index] = source[index];\n  }\n  return array;\n}\n\nmodule.exports = copyArray;\n","var assignValue = require('./_assignValue'),\n    baseAssignValue = require('./_baseAssignValue');\n\n/**\n * Copies properties of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property identifiers to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @param {Function} [customizer] The function to customize copied values.\n * @returns {Object} Returns `object`.\n */\nfunction copyObject(source, props, object, customizer) {\n  var isNew = !object;\n  object || (object = {});\n\n  var index = -1,\n      length = props.length;\n\n  while (++index < length) {\n    var key = props[index];\n\n    var newValue = customizer\n      ? customizer(object[key], source[key], key, object, source)\n      : undefined;\n\n    if (newValue === undefined) {\n      newValue = source[key];\n    }\n    if (isNew) {\n      baseAssignValue(object, key, newValue);\n    } else {\n      assignValue(object, key, newValue);\n    }\n  }\n  return object;\n}\n\nmodule.exports = copyObject;\n","var copyObject = require('./_copyObject'),\n    getSymbols = require('./_getSymbols');\n\n/**\n * Copies own symbols of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy symbols from.\n * @param {Object} [object={}] The object to copy symbols to.\n * @returns {Object} Returns `object`.\n */\nfunction copySymbols(source, object) {\n  return copyObject(source, getSymbols(source), object);\n}\n\nmodule.exports = copySymbols;\n","var copyObject = require('./_copyObject'),\n    getSymbolsIn = require('./_getSymbolsIn');\n\n/**\n * Copies own and inherited symbols of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy symbols from.\n * @param {Object} [object={}] The object to copy symbols to.\n * @returns {Object} Returns `object`.\n */\nfunction copySymbolsIn(source, object) {\n  return copyObject(source, getSymbolsIn(source), object);\n}\n\nmodule.exports = copySymbolsIn;\n","var root = require('./_root');\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\nmodule.exports = coreJsData;\n","var getNative = require('./_getNative');\n\nvar defineProperty = (function() {\n  try {\n    var func = getNative(Object, 'defineProperty');\n    func({}, '', {});\n    return func;\n  } catch (e) {}\n}());\n\nmodule.exports = defineProperty;\n","var SetCache = require('./_SetCache'),\n    arraySome = require('./_arraySome'),\n    cacheHas = require('./_cacheHas');\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n    COMPARE_UNORDERED_FLAG = 2;\n\n/**\n * A specialized version of `baseIsEqualDeep` for arrays with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Array} array The array to compare.\n * @param {Array} other The other array to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `array` and `other` objects.\n * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.\n */\nfunction equalArrays(array, other, bitmask, customizer, equalFunc, stack) {\n  var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n      arrLength = array.length,\n      othLength = other.length;\n\n  if (arrLength != othLength && !(isPartial && othLength > arrLength)) {\n    return false;\n  }\n  // Check that cyclic values are equal.\n  var arrStacked = stack.get(array);\n  var othStacked = stack.get(other);\n  if (arrStacked && othStacked) {\n    return arrStacked == other && othStacked == array;\n  }\n  var index = -1,\n      result = true,\n      seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;\n\n  stack.set(array, other);\n  stack.set(other, array);\n\n  // Ignore non-index properties.\n  while (++index < arrLength) {\n    var arrValue = array[index],\n        othValue = other[index];\n\n    if (customizer) {\n      var compared = isPartial\n        ? customizer(othValue, arrValue, index, other, array, stack)\n        : customizer(arrValue, othValue, index, array, other, stack);\n    }\n    if (compared !== undefined) {\n      if (compared) {\n        continue;\n      }\n      result = false;\n      break;\n    }\n    // Recursively compare arrays (susceptible to call stack limits).\n    if (seen) {\n      if (!arraySome(other, function(othValue, othIndex) {\n            if (!cacheHas(seen, othIndex) &&\n                (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {\n              return seen.push(othIndex);\n            }\n          })) {\n        result = false;\n        break;\n      }\n    } else if (!(\n          arrValue === othValue ||\n            equalFunc(arrValue, othValue, bitmask, customizer, stack)\n        )) {\n      result = false;\n      break;\n    }\n  }\n  stack['delete'](array);\n  stack['delete'](other);\n  return result;\n}\n\nmodule.exports = equalArrays;\n","var Symbol = require('./_Symbol'),\n    Uint8Array = require('./_Uint8Array'),\n    eq = require('./eq'),\n    equalArrays = require('./_equalArrays'),\n    mapToArray = require('./_mapToArray'),\n    setToArray = require('./_setToArray');\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n    COMPARE_UNORDERED_FLAG = 2;\n\n/** `Object#toString` result references. */\nvar boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    symbolTag = '[object Symbol]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]';\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;\n\n/**\n * A specialized version of `baseIsEqualDeep` for comparing objects of\n * the same `toStringTag`.\n *\n * **Note:** This function only supports comparing values with tags of\n * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {string} tag The `toStringTag` of the objects to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {\n  switch (tag) {\n    case dataViewTag:\n      if ((object.byteLength != other.byteLength) ||\n          (object.byteOffset != other.byteOffset)) {\n        return false;\n      }\n      object = object.buffer;\n      other = other.buffer;\n\n    case arrayBufferTag:\n      if ((object.byteLength != other.byteLength) ||\n          !equalFunc(new Uint8Array(object), new Uint8Array(other))) {\n        return false;\n      }\n      return true;\n\n    case boolTag:\n    case dateTag:\n    case numberTag:\n      // Coerce booleans to `1` or `0` and dates to milliseconds.\n      // Invalid dates are coerced to `NaN`.\n      return eq(+object, +other);\n\n    case errorTag:\n      return object.name == other.name && object.message == other.message;\n\n    case regexpTag:\n    case stringTag:\n      // Coerce regexes to strings and treat strings, primitives and objects,\n      // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring\n      // for more details.\n      return object == (other + '');\n\n    case mapTag:\n      var convert = mapToArray;\n\n    case setTag:\n      var isPartial = bitmask & COMPARE_PARTIAL_FLAG;\n      convert || (convert = setToArray);\n\n      if (object.size != other.size && !isPartial) {\n        return false;\n      }\n      // Assume cyclic values are equal.\n      var stacked = stack.get(object);\n      if (stacked) {\n        return stacked == other;\n      }\n      bitmask |= COMPARE_UNORDERED_FLAG;\n\n      // Recursively compare objects (susceptible to call stack limits).\n      stack.set(object, other);\n      var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);\n      stack['delete'](object);\n      return result;\n\n    case symbolTag:\n      if (symbolValueOf) {\n        return symbolValueOf.call(object) == symbolValueOf.call(other);\n      }\n  }\n  return false;\n}\n\nmodule.exports = equalByTag;\n","var getAllKeys = require('./_getAllKeys');\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1;\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * A specialized version of `baseIsEqualDeep` for objects with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction equalObjects(object, other, bitmask, customizer, equalFunc, stack) {\n  var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n      objProps = getAllKeys(object),\n      objLength = objProps.length,\n      othProps = getAllKeys(other),\n      othLength = othProps.length;\n\n  if (objLength != othLength && !isPartial) {\n    return false;\n  }\n  var index = objLength;\n  while (index--) {\n    var key = objProps[index];\n    if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {\n      return false;\n    }\n  }\n  // Check that cyclic values are equal.\n  var objStacked = stack.get(object);\n  var othStacked = stack.get(other);\n  if (objStacked && othStacked) {\n    return objStacked == other && othStacked == object;\n  }\n  var result = true;\n  stack.set(object, other);\n  stack.set(other, object);\n\n  var skipCtor = isPartial;\n  while (++index < objLength) {\n    key = objProps[index];\n    var objValue = object[key],\n        othValue = other[key];\n\n    if (customizer) {\n      var compared = isPartial\n        ? customizer(othValue, objValue, key, other, object, stack)\n        : customizer(objValue, othValue, key, object, other, stack);\n    }\n    // Recursively compare objects (susceptible to call stack limits).\n    if (!(compared === undefined\n          ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))\n          : compared\n        )) {\n      result = false;\n      break;\n    }\n    skipCtor || (skipCtor = key == 'constructor');\n  }\n  if (result && !skipCtor) {\n    var objCtor = object.constructor,\n        othCtor = other.constructor;\n\n    // Non `Object` object instances with different constructors are not equal.\n    if (objCtor != othCtor &&\n        ('constructor' in object && 'constructor' in other) &&\n        !(typeof objCtor == 'function' && objCtor instanceof objCtor &&\n          typeof othCtor == 'function' && othCtor instanceof othCtor)) {\n      result = false;\n    }\n  }\n  stack['delete'](object);\n  stack['delete'](other);\n  return result;\n}\n\nmodule.exports = equalObjects;\n","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nmodule.exports = freeGlobal;\n","var baseGetAllKeys = require('./_baseGetAllKeys'),\n    getSymbols = require('./_getSymbols'),\n    keys = require('./keys');\n\n/**\n * Creates an array of own enumerable property names and symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction getAllKeys(object) {\n  return baseGetAllKeys(object, keys, getSymbols);\n}\n\nmodule.exports = getAllKeys;\n","var baseGetAllKeys = require('./_baseGetAllKeys'),\n    getSymbolsIn = require('./_getSymbolsIn'),\n    keysIn = require('./keysIn');\n\n/**\n * Creates an array of own and inherited enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction getAllKeysIn(object) {\n  return baseGetAllKeys(object, keysIn, getSymbolsIn);\n}\n\nmodule.exports = getAllKeysIn;\n","var isKeyable = require('./_isKeyable');\n\n/**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\nfunction getMapData(map, key) {\n  var data = map.__data__;\n  return isKeyable(key)\n    ? data[typeof key == 'string' ? 'string' : 'hash']\n    : data.map;\n}\n\nmodule.exports = getMapData;\n","var baseIsNative = require('./_baseIsNative'),\n    getValue = require('./_getValue');\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n  var value = getValue(object, key);\n  return baseIsNative(value) ? value : undefined;\n}\n\nmodule.exports = getNative;\n","var overArg = require('./_overArg');\n\n/** Built-in value references. */\nvar getPrototype = overArg(Object.getPrototypeOf, Object);\n\nmodule.exports = getPrototype;\n","var Symbol = require('./_Symbol');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\nmodule.exports = getRawTag;\n","var arrayFilter = require('./_arrayFilter'),\n    stubArray = require('./stubArray');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeGetSymbols = Object.getOwnPropertySymbols;\n\n/**\n * Creates an array of the own enumerable symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\nvar getSymbols = !nativeGetSymbols ? stubArray : function(object) {\n  if (object == null) {\n    return [];\n  }\n  object = Object(object);\n  return arrayFilter(nativeGetSymbols(object), function(symbol) {\n    return propertyIsEnumerable.call(object, symbol);\n  });\n};\n\nmodule.exports = getSymbols;\n","var arrayPush = require('./_arrayPush'),\n    getPrototype = require('./_getPrototype'),\n    getSymbols = require('./_getSymbols'),\n    stubArray = require('./stubArray');\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeGetSymbols = Object.getOwnPropertySymbols;\n\n/**\n * Creates an array of the own and inherited enumerable symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\nvar getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {\n  var result = [];\n  while (object) {\n    arrayPush(result, getSymbols(object));\n    object = getPrototype(object);\n  }\n  return result;\n};\n\nmodule.exports = getSymbolsIn;\n","var DataView = require('./_DataView'),\n    Map = require('./_Map'),\n    Promise = require('./_Promise'),\n    Set = require('./_Set'),\n    WeakMap = require('./_WeakMap'),\n    baseGetTag = require('./_baseGetTag'),\n    toSource = require('./_toSource');\n\n/** `Object#toString` result references. */\nvar mapTag = '[object Map]',\n    objectTag = '[object Object]',\n    promiseTag = '[object Promise]',\n    setTag = '[object Set]',\n    weakMapTag = '[object WeakMap]';\n\nvar dataViewTag = '[object DataView]';\n\n/** Used to detect maps, sets, and weakmaps. */\nvar dataViewCtorString = toSource(DataView),\n    mapCtorString = toSource(Map),\n    promiseCtorString = toSource(Promise),\n    setCtorString = toSource(Set),\n    weakMapCtorString = toSource(WeakMap);\n\n/**\n * Gets the `toStringTag` of `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nvar getTag = baseGetTag;\n\n// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.\nif ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||\n    (Map && getTag(new Map) != mapTag) ||\n    (Promise && getTag(Promise.resolve()) != promiseTag) ||\n    (Set && getTag(new Set) != setTag) ||\n    (WeakMap && getTag(new WeakMap) != weakMapTag)) {\n  getTag = function(value) {\n    var result = baseGetTag(value),\n        Ctor = result == objectTag ? value.constructor : undefined,\n        ctorString = Ctor ? toSource(Ctor) : '';\n\n    if (ctorString) {\n      switch (ctorString) {\n        case dataViewCtorString: return dataViewTag;\n        case mapCtorString: return mapTag;\n        case promiseCtorString: return promiseTag;\n        case setCtorString: return setTag;\n        case weakMapCtorString: return weakMapTag;\n      }\n    }\n    return result;\n  };\n}\n\nmodule.exports = getTag;\n","/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue(object, key) {\n  return object == null ? undefined : object[key];\n}\n\nmodule.exports = getValue;\n","var nativeCreate = require('./_nativeCreate');\n\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\nfunction hashClear() {\n  this.__data__ = nativeCreate ? nativeCreate(null) : {};\n  this.size = 0;\n}\n\nmodule.exports = hashClear;\n","/**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction hashDelete(key) {\n  var result = this.has(key) && delete this.__data__[key];\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\nmodule.exports = hashDelete;\n","var nativeCreate = require('./_nativeCreate');\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction hashGet(key) {\n  var data = this.__data__;\n  if (nativeCreate) {\n    var result = data[key];\n    return result === HASH_UNDEFINED ? undefined : result;\n  }\n  return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n\nmodule.exports = hashGet;\n","var nativeCreate = require('./_nativeCreate');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction hashHas(key) {\n  var data = this.__data__;\n  return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);\n}\n\nmodule.exports = hashHas;\n","var nativeCreate = require('./_nativeCreate');\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\nfunction hashSet(key, value) {\n  var data = this.__data__;\n  this.size += this.has(key) ? 0 : 1;\n  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n  return this;\n}\n\nmodule.exports = hashSet;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Initializes an array clone.\n *\n * @private\n * @param {Array} array The array to clone.\n * @returns {Array} Returns the initialized clone.\n */\nfunction initCloneArray(array) {\n  var length = array.length,\n      result = new array.constructor(length);\n\n  // Add properties assigned by `RegExp#exec`.\n  if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {\n    result.index = array.index;\n    result.input = array.input;\n  }\n  return result;\n}\n\nmodule.exports = initCloneArray;\n","var cloneArrayBuffer = require('./_cloneArrayBuffer'),\n    cloneDataView = require('./_cloneDataView'),\n    cloneRegExp = require('./_cloneRegExp'),\n    cloneSymbol = require('./_cloneSymbol'),\n    cloneTypedArray = require('./_cloneTypedArray');\n\n/** `Object#toString` result references. */\nvar boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    symbolTag = '[object Symbol]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]',\n    float32Tag = '[object Float32Array]',\n    float64Tag = '[object Float64Array]',\n    int8Tag = '[object Int8Array]',\n    int16Tag = '[object Int16Array]',\n    int32Tag = '[object Int32Array]',\n    uint8Tag = '[object Uint8Array]',\n    uint8ClampedTag = '[object Uint8ClampedArray]',\n    uint16Tag = '[object Uint16Array]',\n    uint32Tag = '[object Uint32Array]';\n\n/**\n * Initializes an object clone based on its `toStringTag`.\n *\n * **Note:** This function only supports cloning values with tags of\n * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`.\n *\n * @private\n * @param {Object} object The object to clone.\n * @param {string} tag The `toStringTag` of the object to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the initialized clone.\n */\nfunction initCloneByTag(object, tag, isDeep) {\n  var Ctor = object.constructor;\n  switch (tag) {\n    case arrayBufferTag:\n      return cloneArrayBuffer(object);\n\n    case boolTag:\n    case dateTag:\n      return new Ctor(+object);\n\n    case dataViewTag:\n      return cloneDataView(object, isDeep);\n\n    case float32Tag: case float64Tag:\n    case int8Tag: case int16Tag: case int32Tag:\n    case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:\n      return cloneTypedArray(object, isDeep);\n\n    case mapTag:\n      return new Ctor;\n\n    case numberTag:\n    case stringTag:\n      return new Ctor(object);\n\n    case regexpTag:\n      return cloneRegExp(object);\n\n    case setTag:\n      return new Ctor;\n\n    case symbolTag:\n      return cloneSymbol(object);\n  }\n}\n\nmodule.exports = initCloneByTag;\n","var baseCreate = require('./_baseCreate'),\n    getPrototype = require('./_getPrototype'),\n    isPrototype = require('./_isPrototype');\n\n/**\n * Initializes an object clone.\n *\n * @private\n * @param {Object} object The object to clone.\n * @returns {Object} Returns the initialized clone.\n */\nfunction initCloneObject(object) {\n  return (typeof object.constructor == 'function' && !isPrototype(object))\n    ? baseCreate(getPrototype(object))\n    : {};\n}\n\nmodule.exports = initCloneObject;\n","/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n  var type = typeof value;\n  length = length == null ? MAX_SAFE_INTEGER : length;\n\n  return !!length &&\n    (type == 'number' ||\n      (type != 'symbol' && reIsUint.test(value))) &&\n        (value > -1 && value % 1 == 0 && value < length);\n}\n\nmodule.exports = isIndex;\n","/**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\nfunction isKeyable(value) {\n  var type = typeof value;\n  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n    ? (value !== '__proto__')\n    : (value === null);\n}\n\nmodule.exports = isKeyable;\n","var coreJsData = require('./_coreJsData');\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = (function() {\n  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n  return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n  return !!maskSrcKey && (maskSrcKey in func);\n}\n\nmodule.exports = isMasked;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n  var Ctor = value && value.constructor,\n      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n  return value === proto;\n}\n\nmodule.exports = isPrototype;\n","/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\nfunction listCacheClear() {\n  this.__data__ = [];\n  this.size = 0;\n}\n\nmodule.exports = listCacheClear;\n","var assocIndexOf = require('./_assocIndexOf');\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype;\n\n/** Built-in value references. */\nvar splice = arrayProto.splice;\n\n/**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction listCacheDelete(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    return false;\n  }\n  var lastIndex = data.length - 1;\n  if (index == lastIndex) {\n    data.pop();\n  } else {\n    splice.call(data, index, 1);\n  }\n  --this.size;\n  return true;\n}\n\nmodule.exports = listCacheDelete;\n","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction listCacheGet(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  return index < 0 ? undefined : data[index][1];\n}\n\nmodule.exports = listCacheGet;\n","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction listCacheHas(key) {\n  return assocIndexOf(this.__data__, key) > -1;\n}\n\nmodule.exports = listCacheHas;\n","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\nfunction listCacheSet(key, value) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    ++this.size;\n    data.push([key, value]);\n  } else {\n    data[index][1] = value;\n  }\n  return this;\n}\n\nmodule.exports = listCacheSet;\n","var Hash = require('./_Hash'),\n    ListCache = require('./_ListCache'),\n    Map = require('./_Map');\n\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\nfunction mapCacheClear() {\n  this.size = 0;\n  this.__data__ = {\n    'hash': new Hash,\n    'map': new (Map || ListCache),\n    'string': new Hash\n  };\n}\n\nmodule.exports = mapCacheClear;\n","var getMapData = require('./_getMapData');\n\n/**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction mapCacheDelete(key) {\n  var result = getMapData(this, key)['delete'](key);\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\nmodule.exports = mapCacheDelete;\n","var getMapData = require('./_getMapData');\n\n/**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction mapCacheGet(key) {\n  return getMapData(this, key).get(key);\n}\n\nmodule.exports = mapCacheGet;\n","var getMapData = require('./_getMapData');\n\n/**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction mapCacheHas(key) {\n  return getMapData(this, key).has(key);\n}\n\nmodule.exports = mapCacheHas;\n","var getMapData = require('./_getMapData');\n\n/**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\nfunction mapCacheSet(key, value) {\n  var data = getMapData(this, key),\n      size = data.size;\n\n  data.set(key, value);\n  this.size += data.size == size ? 0 : 1;\n  return this;\n}\n\nmodule.exports = mapCacheSet;\n","/**\n * Converts `map` to its key-value pairs.\n *\n * @private\n * @param {Object} map The map to convert.\n * @returns {Array} Returns the key-value pairs.\n */\nfunction mapToArray(map) {\n  var index = -1,\n      result = Array(map.size);\n\n  map.forEach(function(value, key) {\n    result[++index] = [key, value];\n  });\n  return result;\n}\n\nmodule.exports = mapToArray;\n","var getNative = require('./_getNative');\n\n/* Built-in method references that are verified to be native. */\nvar nativeCreate = getNative(Object, 'create');\n\nmodule.exports = nativeCreate;\n","var overArg = require('./_overArg');\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeKeys = overArg(Object.keys, Object);\n\nmodule.exports = nativeKeys;\n","/**\n * This function is like\n * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * except that it includes inherited enumerable properties.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction nativeKeysIn(object) {\n  var result = [];\n  if (object != null) {\n    for (var key in Object(object)) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nmodule.exports = nativeKeysIn;\n","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Detect free variable `process` from Node.js. */\nvar freeProcess = moduleExports && freeGlobal.process;\n\n/** Used to access faster Node.js helpers. */\nvar nodeUtil = (function() {\n  try {\n    // Use `util.types` for Node.js 10+.\n    var types = freeModule && freeModule.require && freeModule.require('util').types;\n\n    if (types) {\n      return types;\n    }\n\n    // Legacy `process.binding('util')` for Node.js < 10.\n    return freeProcess && freeProcess.binding && freeProcess.binding('util');\n  } catch (e) {}\n}());\n\nmodule.exports = nodeUtil;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n\nmodule.exports = objectToString;\n","/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n  return function(arg) {\n    return func(transform(arg));\n  };\n}\n\nmodule.exports = overArg;\n","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nmodule.exports = root;\n","/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/**\n * Adds `value` to the array cache.\n *\n * @private\n * @name add\n * @memberOf SetCache\n * @alias push\n * @param {*} value The value to cache.\n * @returns {Object} Returns the cache instance.\n */\nfunction setCacheAdd(value) {\n  this.__data__.set(value, HASH_UNDEFINED);\n  return this;\n}\n\nmodule.exports = setCacheAdd;\n","/**\n * Checks if `value` is in the array cache.\n *\n * @private\n * @name has\n * @memberOf SetCache\n * @param {*} value The value to search for.\n * @returns {number} Returns `true` if `value` is found, else `false`.\n */\nfunction setCacheHas(value) {\n  return this.__data__.has(value);\n}\n\nmodule.exports = setCacheHas;\n","/**\n * Converts `set` to an array of its values.\n *\n * @private\n * @param {Object} set The set to convert.\n * @returns {Array} Returns the values.\n */\nfunction setToArray(set) {\n  var index = -1,\n      result = Array(set.size);\n\n  set.forEach(function(value) {\n    result[++index] = value;\n  });\n  return result;\n}\n\nmodule.exports = setToArray;\n","var ListCache = require('./_ListCache');\n\n/**\n * Removes all key-value entries from the stack.\n *\n * @private\n * @name clear\n * @memberOf Stack\n */\nfunction stackClear() {\n  this.__data__ = new ListCache;\n  this.size = 0;\n}\n\nmodule.exports = stackClear;\n","/**\n * Removes `key` and its value from the stack.\n *\n * @private\n * @name delete\n * @memberOf Stack\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction stackDelete(key) {\n  var data = this.__data__,\n      result = data['delete'](key);\n\n  this.size = data.size;\n  return result;\n}\n\nmodule.exports = stackDelete;\n","/**\n * Gets the stack value for `key`.\n *\n * @private\n * @name get\n * @memberOf Stack\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction stackGet(key) {\n  return this.__data__.get(key);\n}\n\nmodule.exports = stackGet;\n","/**\n * Checks if a stack value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Stack\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction stackHas(key) {\n  return this.__data__.has(key);\n}\n\nmodule.exports = stackHas;\n","var ListCache = require('./_ListCache'),\n    Map = require('./_Map'),\n    MapCache = require('./_MapCache');\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/**\n * Sets the stack `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Stack\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the stack cache instance.\n */\nfunction stackSet(key, value) {\n  var data = this.__data__;\n  if (data instanceof ListCache) {\n    var pairs = data.__data__;\n    if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n      pairs.push([key, value]);\n      this.size = ++data.size;\n      return this;\n    }\n    data = this.__data__ = new MapCache(pairs);\n  }\n  data.set(key, value);\n  this.size = data.size;\n  return this;\n}\n\nmodule.exports = stackSet;\n","/** Used for built-in method references. */\nvar funcProto = Function.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to convert.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n  if (func != null) {\n    try {\n      return funcToString.call(func);\n    } catch (e) {}\n    try {\n      return (func + '');\n    } catch (e) {}\n  }\n  return '';\n}\n\nmodule.exports = toSource;\n","var baseClone = require('./_baseClone');\n\n/** Used to compose bitmasks for cloning. */\nvar CLONE_DEEP_FLAG = 1,\n    CLONE_SYMBOLS_FLAG = 4;\n\n/**\n * This method is like `_.clone` except that it recursively clones `value`.\n *\n * @static\n * @memberOf _\n * @since 1.0.0\n * @category Lang\n * @param {*} value The value to recursively clone.\n * @returns {*} Returns the deep cloned value.\n * @see _.clone\n * @example\n *\n * var objects = [{ 'a': 1 }, { 'b': 2 }];\n *\n * var deep = _.cloneDeep(objects);\n * console.log(deep[0] === objects[0]);\n * // => false\n */\nfunction cloneDeep(value) {\n  return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);\n}\n\nmodule.exports = cloneDeep;\n","/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n  return value === other || (value !== value && other !== other);\n}\n\nmodule.exports = eq;\n","var baseIsArguments = require('./_baseIsArguments'),\n    isObjectLike = require('./isObjectLike');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n *  else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nvar isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\n  return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&\n    !propertyIsEnumerable.call(value, 'callee');\n};\n\nmodule.exports = isArguments;\n","/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\nmodule.exports = isArray;\n","var isFunction = require('./isFunction'),\n    isLength = require('./isLength');\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n  return value != null && isLength(value.length) && !isFunction(value);\n}\n\nmodule.exports = isArrayLike;\n","var root = require('./_root'),\n    stubFalse = require('./stubFalse');\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;\n\n/**\n * Checks if `value` is a buffer.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n *\n * _.isBuffer(new Buffer(2));\n * // => true\n *\n * _.isBuffer(new Uint8Array(2));\n * // => false\n */\nvar isBuffer = nativeIsBuffer || stubFalse;\n\nmodule.exports = isBuffer;\n","var baseIsEqual = require('./_baseIsEqual');\n\n/**\n * Performs a deep comparison between two values to determine if they are\n * equivalent.\n *\n * **Note:** This method supports comparing arrays, array buffers, booleans,\n * date objects, error objects, maps, numbers, `Object` objects, regexes,\n * sets, strings, symbols, and typed arrays. `Object` objects are compared\n * by their own, not inherited, enumerable properties. Functions and DOM\n * nodes are compared by strict equality, i.e. `===`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.isEqual(object, other);\n * // => true\n *\n * object === other;\n * // => false\n */\nfunction isEqual(value, other) {\n  return baseIsEqual(value, other);\n}\n\nmodule.exports = isEqual;\n","var baseGetTag = require('./_baseGetTag'),\n    isObject = require('./isObject');\n\n/** `Object#toString` result references. */\nvar asyncTag = '[object AsyncFunction]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    proxyTag = '[object Proxy]';\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  if (!isObject(value)) {\n    return false;\n  }\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 9 which returns 'object' for typed arrays and other constructors.\n  var tag = baseGetTag(value);\n  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n}\n\nmodule.exports = isFunction;\n","/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n  return typeof value == 'number' &&\n    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\nmodule.exports = isLength;\n","var baseIsMap = require('./_baseIsMap'),\n    baseUnary = require('./_baseUnary'),\n    nodeUtil = require('./_nodeUtil');\n\n/* Node.js helper references. */\nvar nodeIsMap = nodeUtil && nodeUtil.isMap;\n\n/**\n * Checks if `value` is classified as a `Map` object.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a map, else `false`.\n * @example\n *\n * _.isMap(new Map);\n * // => true\n *\n * _.isMap(new WeakMap);\n * // => false\n */\nvar isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;\n\nmodule.exports = isMap;\n","/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return value != null && (type == 'object' || type == 'function');\n}\n\nmodule.exports = isObject;\n","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\nmodule.exports = isObjectLike;\n","var baseIsSet = require('./_baseIsSet'),\n    baseUnary = require('./_baseUnary'),\n    nodeUtil = require('./_nodeUtil');\n\n/* Node.js helper references. */\nvar nodeIsSet = nodeUtil && nodeUtil.isSet;\n\n/**\n * Checks if `value` is classified as a `Set` object.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a set, else `false`.\n * @example\n *\n * _.isSet(new Set);\n * // => true\n *\n * _.isSet(new WeakSet);\n * // => false\n */\nvar isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;\n\nmodule.exports = isSet;\n","var baseIsTypedArray = require('./_baseIsTypedArray'),\n    baseUnary = require('./_baseUnary'),\n    nodeUtil = require('./_nodeUtil');\n\n/* Node.js helper references. */\nvar nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n\n/**\n * Checks if `value` is classified as a typed array.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n * @example\n *\n * _.isTypedArray(new Uint8Array);\n * // => true\n *\n * _.isTypedArray([]);\n * // => false\n */\nvar isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\nmodule.exports = isTypedArray;\n","var arrayLikeKeys = require('./_arrayLikeKeys'),\n    baseKeys = require('./_baseKeys'),\n    isArrayLike = require('./isArrayLike');\n\n/**\n * Creates an array of the own enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * for more details.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keys(new Foo);\n * // => ['a', 'b'] (iteration order is not guaranteed)\n *\n * _.keys('hi');\n * // => ['0', '1']\n */\nfunction keys(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n}\n\nmodule.exports = keys;\n","var arrayLikeKeys = require('./_arrayLikeKeys'),\n    baseKeysIn = require('./_baseKeysIn'),\n    isArrayLike = require('./isArrayLike');\n\n/**\n * Creates an array of the own and inherited enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keysIn(new Foo);\n * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n */\nfunction keysIn(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);\n}\n\nmodule.exports = keysIn;\n","/**\n * This method returns a new empty array.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {Array} Returns the new empty array.\n * @example\n *\n * var arrays = _.times(2, _.stubArray);\n *\n * console.log(arrays);\n * // => [[], []]\n *\n * console.log(arrays[0] === arrays[1]);\n * // => false\n */\nfunction stubArray() {\n  return [];\n}\n\nmodule.exports = stubArray;\n","/**\n * This method returns `false`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n *\n * _.times(2, _.stubFalse);\n * // => [false, false]\n */\nfunction stubFalse() {\n  return false;\n}\n\nmodule.exports = stubFalse;\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\tid: moduleId,\n\t\tloaded: false,\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Flag the module as loaded\n\tmodule.loaded = true;\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","__webpack_require__.nmd = (module) => {\n\tmodule.paths = [];\n\tif (!module.children) module.children = [];\n\treturn module;\n};","import type OpenFin from \"@openfin/core\";\nimport { fin } from \"@openfin/core\";\n\nconst channelName = `${fin.me.identity.uuid}-logger`;\nlet channelClient: OpenFin.ChannelClient;\n\nwindow.addEventListener(\"DOMContentLoaded\", async () => {\n\tconst consoleLogBtn = document.querySelector<HTMLButtonElement>(\"#console-app-log\");\n\tif (consoleLogBtn) {\n\t\tconsoleLogBtn.addEventListener(\"click\", consoleLogMessage);\n\t}\n\n\tconst channelLogBtn = document.querySelector<HTMLButtonElement>(\"#channel-app-log\");\n\tif (channelLogBtn) {\n\t\tchannelLogBtn.addEventListener(\"click\", channelLogMessage);\n\t}\n\n\tconst clearPreviewBtn = document.querySelector<HTMLButtonElement>(\"#clear-preview\");\n\tif (clearPreviewBtn) {\n\t\tclearPreviewBtn.addEventListener(\"click\", clearPreview);\n\t}\n\tawait setupChannelClient();\n});\n\n/**\n * Sends a message to console log.\n */\nasync function consoleLogMessage(): Promise<void> {\n\tconst logPreview = document.querySelector(\"#preview\");\n\ttry {\n\t\tconst message = `Sending view console log message: ${Date.now()}`;\n\t\tconsole.log(message);\n\t\tif (logPreview) {\n\t\t\tlogPreview.textContent += `\nConsole Logged the following message: \n\"${message}\"`;\n\t\t}\n\t} catch (err: unknown) {\n\t\tif (logPreview) {\n\t\t\tlogPreview.textContent += `Error console logging message: ${(err as Error).message}`;\n\t\t}\n\t}\n}\n\n/**\n * Sends a message to console log through the Channel API.\n */\nasync function channelLogMessage(): Promise<void> {\n\tconst logPreview = document.querySelector(\"#preview\");\n\ttry {\n\t\tconst message = `Sending view channel log message: ${Date.now()}`;\n\t\tif (logPreview) {\n\t\t\tlogPreview.textContent += `\nSending the following message through the Channel API: \n\"${message}\"`;\n\t\t}\n\t\tawait channelClient.dispatch(\"log\", message);\n\t} catch (err: unknown) {\n\t\tif (logPreview) {\n\t\t\tlogPreview.textContent += `Error sending message through Channel API: ${(err as Error).message}`;\n\t\t}\n\t}\n}\n\n/**\n * Sets up the Channel Client.\n */\nasync function setupChannelClient(): Promise<void> {\n\tif (channelClient === undefined) {\n\t\tchannelClient = await fin.InterApplicationBus.Channel.connect(channelName);\n\t}\n}\n\n/**\n * Clears the preview log.\n */\nfunction clearPreview(): void {\n\tconst logPreview = document.querySelector(\"#preview\");\n\tif (logPreview) {\n\t\tlogPreview.textContent = \"\";\n\t}\n}\n"],"names":[],"sourceRoot":""}
\ No newline at end of file
diff --git a/dev/john/update-logging-example/use-logging-apis/js/provider.bundle.js b/dev/john/update-logging-example/use-logging-apis/js/provider.bundle.js
new file mode 100644
index 00000000..edaa8c7b
--- /dev/null
+++ b/dev/john/update-logging-example/use-logging-apis/js/provider.bundle.js
@@ -0,0 +1,22885 @@
+/******/ (() => { // webpackBootstrap
+/******/ 	var __webpack_modules__ = ({
+
+/***/ "../../node_modules/@openfin/core/out/mock.js":
+/*!****************************************************!*\
+  !*** ../../node_modules/@openfin/core/out/mock.js ***!
+  \****************************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+var require$$0 = __webpack_require__(/*! events */ "../../node_modules/events/events.js");
+var require$$0$1 = __webpack_require__(/*! lodash/cloneDeep */ "../../node_modules/lodash/cloneDeep.js");
+var require$$3 = __webpack_require__(/*! lodash/isEqual */ "../../node_modules/lodash/isEqual.js");
+
+function _mergeNamespaces(n, m) {
+	m.forEach(function (e) {
+		e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
+			if (k !== 'default' && !(k in n)) {
+				var d = Object.getOwnPropertyDescriptor(e, k);
+				Object.defineProperty(n, k, d.get ? d : {
+					enumerable: true,
+					get: function () { return e[k]; }
+				});
+			}
+		});
+	});
+	return Object.freeze(n);
+}
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof __webpack_require__.g !== 'undefined' ? __webpack_require__.g : typeof self !== 'undefined' ? self : {};
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var OpenFin$2 = {};
+
+var events = {};
+
+var application$1 = {};
+
+/**
+ * Namespace for events that can be emitted by an {@link OpenFin.Application}.  Includes events
+ * re-propagated from the {@link OpenFin.Window} (and, transitively, {@link OpenFin.View}) level, prefixed with `window-` (and also, if applicable, `view-`).
+ * For example, a view's "attached" event will fire as 'window-view-attached' at the application level.
+ *
+ * Event payloads are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.
+ * Events gain metadata as they propagate, which is *not* present on the explicit payload interfaces.  To refer to the full type
+ * of an event as it would be raised on this emitter, use {@link Payload}.
+ *
+ * This namespace contains only payload shapes for events that are unique to `Application`.  Events that propagate to `Application` from
+ * child {@link OpenFin.Window windows} and {@link OpenFin.View views} are defined in the {@link OpenFin.WindowEvents} and
+ * {@link OpenFin.ViewEvents} namespaces.  For a list of valid string keys for *all* application events, see {@link Application.on Application.on}.
+ *
+ * {@link ApplicationSourcedEvent Application-sourced events} (i.e. those that have not propagated from {@link OpenFin.ViewEvents Views}
+ * or {@link OpenFin.WindowEvents Windows} re-propagate to {@link OpenFin.SystemEvents System} with their type string prefixed with `application-`.
+ * {@link ApplicationWindowEvent Application events that are tied to Windows but do not propagate from them}
+ * are propagated to `System` without any type string prefixing.
+ *
+ * "Requested" events (e.g. {@link RunRequestedEvent}) do not propagate.
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(application$1, "__esModule", { value: true });
+
+var base$1 = {};
+
+/**
+ * Namespace for shared event payloads and utility types common to all event emitters.
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(base$1, "__esModule", { value: true });
+
+var externalApplication$1 = {};
+
+/**
+ * Namespace for events that can be transmitted by an {@link OpenFin.ExternalApplication}.
+ *
+ * Event payloads are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.
+ * Events gain metadata as they propagate, which is *not* present on the explicit payload interfaces.  To refer to the full type
+ * of an event as it would be raised on this emitter, use {@link Payload}.
+ *
+ * For a list of valid string keys for external application events, see {@link ExternalApplication.on ExternalApplication.on}.
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(externalApplication$1, "__esModule", { value: true });
+
+var frame$1 = {};
+
+Object.defineProperty(frame$1, "__esModule", { value: true });
+
+var globalHotkey$1 = {};
+
+/**
+ *
+ * Namespace for events that can be transmitted by {@link GlobalHotkey.GlobalHotkey}.
+ *
+ * Event payloads are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.
+ * Events gain metadata as they propagate, which is *not* present on the explicit payload interfaces.  To refer to the full type
+ * of an event as it would be raised on this emitter, use {@link Payload}.
+ *
+ * For a list of valid string keys for global hotkey events, see {@link GlobalHotkey.GlobalHotkey.on GlobalHotkey.on}.
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(globalHotkey$1, "__esModule", { value: true });
+
+var platform$1 = {};
+
+/**
+ *
+ * Namespace for events that can emitted by a {@link OpenFin.Platform}.
+ *
+ * Event payloads are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.
+ * Events gain metadata as they propagate, which is *not* present on the explicit payload interfaces.  To refer to the full type
+ * of an event as it would be raised on this emitter, use {@link Payload}.
+ *
+ * The Platform `EventEmitter` is a superset of the {@link OpenFin.Application} `EventEmitter`,
+ * meaning it can listen to all {@link OpenFin.ApplicationEvents Application events} in addition to the
+ * Platform-specific events listed here.  For a list of valid string keys for *all* platform events, see
+ * {@link Platform.on Platform.on}.
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(platform$1, "__esModule", { value: true });
+
+var system$1 = {};
+
+/**
+ * Namespace for runtime-wide OpenFin events emitted by {@link System.System}.  Includes events
+ * re-propagated from {@link OpenFin.Application}, {@link OpenFin.Window}, and {@link OpenFin.View} (prefixed with `application-`, `window-`, and `view-`).  All
+ * event propagations are visible at the System level. Propagated events from WebContents (windows, views, frames) to the Application level will *not*
+ * transitively re-propagate to the System level, because they are already visible at the system level and contain the identity
+ * of the application.  For example, an application's "closed" event will fire as 'application-closed' at the system level.  A view's 'shown' event
+ * will be visible as 'view-shown' at the system level, but *not* as `application-window-view-shown`.
+ *
+ * Event payloads are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.
+ * Events gain metadata as they propagate, which is *not* present on the explicit payload interfaces.  To refer to the full type
+ * of an event as it would be raised on this emitter, use {@link Payload}.
+ *
+ * This namespace contains only payload shapes for events that are unique to `System`.  Events that propagate to `System` from
+ * child {@link OpenFin.Application applications}, {@link OpenFin.Window windows}, and {@link OpenFin.View views} are defined in the
+ * {@link OpenFin.ApplicationEvents}, {@link OpenFin.WindowEvents}, and {@link OpenFin.ViewEvents} namespaces.  For a list of valid string keys for *all*
+ * system events, see {@link System.on System.on}.
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(system$1, "__esModule", { value: true });
+
+var view$1 = {};
+
+/**
+ * Namespace for events that can be emitted by a {@link OpenFin.View}.
+ *
+ * Event payloads are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.
+ * Events gain metadata as they propagate, which is *not* present on the explicit payload interfaces.  To refer to the full type
+ * of an event as it would be raised on this emitter, use {@link Payload}.
+ *
+ * This namespace contains only payload shapes for events that are unique to `View`.  Events that are shared between all `WebContents`
+ * (i.e. {@link OpenFin.Window}, {@link OpenFin.View}) are defined in {@link OpenFin.WebContentsEvents}.  For a list
+ * of valid string keys for *all* View events, see {@link View.on View.on}.
+ *
+ * View events propagate to their parent {@link OpenFin.WindowEvents Window}, {@link OpenFin.ApplicationEvents Application},
+ * and {@link OpenFin.SystemEvents System} with an added `viewIdentity` property and their event types prefixed with `'view-'`.
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(view$1, "__esModule", { value: true });
+
+var webcontents = {};
+
+/**
+ * Namespace for events shared by all OpenFin WebContents elements (i.e. {@link OpenFin.Window},
+ * {@link OpenFin.View}).
+ *
+ * WebContents events will re-emit on parent entities - e.g., a propagating event in a view will also be emitted on the view's
+ * parent window, and propagating events in a window will also be emitted on the window's parent {@link OpenFin.Application}.
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(webcontents, "__esModule", { value: true });
+
+var window$2 = {};
+
+/**
+ * Namespace for events that can be emitted by a {@link OpenFin.Window}.
+ *
+ * Event payloads are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.
+ * Events gain metadata as they propagate, which is *not* present on the explicit payload interfaces.  To refer to the full type
+ * of an event as it would be raised on this emitter, use {@link Payload}.
+ *
+ * This namespace contains only payload shapes for events that are unique to `Window`.  Events that are shared between all `WebContents`
+ * (i.e. {@link OpenFin.Window}, {@link OpenFin.View}) are defined in {@link OpenFin.WebContentsEvents}. Events that
+ * propagate from `View` are defined in {@link OpenFin.ViewEvents}. For a list of valid string keys for *all* Window events, see
+ * {@link Window.on Window.on}
+ *
+ * {@link OpenFin.WindowEvents.WindowSourcedEvent Window-sourced events} (i.e. those that are not propagated from a
+ * {@link OpenFin.ViewEvents View}) propagate to their parent {@link OpenFin.ApplicationEvents Application} and
+ * {@link OpenFin.SystemEvents System} with their event types prefixed with `'window-'`).
+ *
+ * "Requested" events (e.g. {@link AuthRequestedEvent}) do not propagate to `System.  The {@link OpenFin.WindowEvents.WindowCloseRequestedEvent}
+ * does not propagate at all.
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(window$2, "__esModule", { value: true });
+
+/**
+ * Namespace for OpenFin event types. Each entity that emits OpenFin events has its own sub-namespace. Event payloads
+ * themselves are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.
+ *
+ * #### Event emitters
+ *
+ * The following entities emit OpenFin events, and have corresponding sub-namespaces:
+ *
+ * * {@link OpenFin.Application}: {@link OpenFin.ApplicationEvents}
+ * * {@link OpenFin.ExternalApplication}: {@link OpenFin.ExternalApplicationEvents}
+ * * {@link OpenFin.Frame}: {@link OpenFin.FrameEvents}
+ * * {@link OpenFin.GlobalHotkey}: {@link OpenFin.GlobalHotkeyEvents}
+ * * {@link OpenFin.Platform}: {@link OpenFin.PlatformEvents}
+ * * {@link OpenFin.System}: {@link OpenFin.SystemEvents}
+ * * {@link OpenFin.View}: {@link OpenFin.ViewEvents}
+ * * {@link OpenFin.Window}: {@link OpenFin.WindowEvents}
+ *
+ * These `EventEmitter` entities share a common set of methods for interacting with the OpenFin event bus, which can be
+ * seen on the individual documentation pages for each entity type.
+ *
+ * Registering event handlers is an asynchronous operation. It is important to ensure that the returned Promises are awaited to reduce the
+ * risk of race conditions.
+ *
+ * When the `EventEmitter` receives an event from the browser process and emits on the renderer, all of the functions attached to that
+ * specific event are called synchronously. Any values returned by the called listeners are ignored and will be discarded.  If the window document
+ * is destroyed by page navigation or reload, its registered event listeners will be removed.
+ *
+ * We recommend using Arrow Functions for event listeners to ensure the this scope is consistent with the original function context.
+ *
+ * Events re-propagate from smaller/more-local scopes to larger/more-global scopes.  For example, an event emitted on a specific
+ * view will propagate to the window in which the view is embedded, and then to the application in which the window is running, and
+ * finally to the OpenFin runtime itself at the "system" level.  For details on propagation semantics, see the namespace for
+ * the propagating (or propagated-to) entity.
+ *
+ * If you need the payload type for a specific type of event (especially propagated events), use the emitting topic's `Payload` generic
+ * (e.g. {@link WindowEvents.Payload}) with the event's `type` string.  For example, the payload of
+ * a {@link ViewEvents.CreatedEvent} after it has propagated to its parent {@link WindowEvents Window} can be found with
+ * `WindowEvents.Payload<'view-created'>`.
+ *
+ * @packageDocumentation
+ */
+var __createBinding$1 = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault$1 = (commonjsGlobal && commonjsGlobal.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar$1 = (commonjsGlobal && commonjsGlobal.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding$1(result, mod, k);
+    __setModuleDefault$1(result, mod);
+    return result;
+};
+Object.defineProperty(events, "__esModule", { value: true });
+events.WindowEvents = events.WebContentsEvents = events.ViewEvents = events.SystemEvents = events.PlatformEvents = events.GlobalHotkeyEvents = events.FrameEvents = events.ExternalApplicationEvents = events.BaseEvents = events.ApplicationEvents = void 0;
+const ApplicationEvents = __importStar$1(application$1);
+events.ApplicationEvents = ApplicationEvents;
+const BaseEvents = __importStar$1(base$1);
+events.BaseEvents = BaseEvents;
+const ExternalApplicationEvents = __importStar$1(externalApplication$1);
+events.ExternalApplicationEvents = ExternalApplicationEvents;
+const FrameEvents = __importStar$1(frame$1);
+events.FrameEvents = FrameEvents;
+const GlobalHotkeyEvents = __importStar$1(globalHotkey$1);
+events.GlobalHotkeyEvents = GlobalHotkeyEvents;
+const PlatformEvents = __importStar$1(platform$1);
+events.PlatformEvents = PlatformEvents;
+const SystemEvents = __importStar$1(system$1);
+events.SystemEvents = SystemEvents;
+const ViewEvents = __importStar$1(view$1);
+events.ViewEvents = ViewEvents;
+const WebContentsEvents = __importStar$1(webcontents);
+events.WebContentsEvents = WebContentsEvents;
+const WindowEvents = __importStar$1(window$2);
+events.WindowEvents = WindowEvents;
+
+(function (exports) {
+	/**
+	 * Top-level namespace for types referenced by the OpenFin API.  Contains:
+	 *
+	 * * The type of the global `fin` entry point ({@link FinApi})
+	 * * Classes that act as static namespaces returned from the `fin` global (e.g. {@link ApplicationModule}, accessible via `fin.Application`)
+	 * * Instance classes that are returned from API calls (e.g. {@link Application}, accessible via `fin.Application.getCurrentSync()`)
+	 * * Parameter shapes for API methods (e.g. {@link ApplicationOptions}, used in `fin.Application.start()`)
+	 * * Event namespaces and payload union types (e.g. {@link ApplicationEvents} and {@link ApplicationEvent})
+	 *
+	 * @packageDocumentation
+	 */
+	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    var desc = Object.getOwnPropertyDescriptor(m, k);
+	    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+	      desc = { enumerable: true, get: function() { return m[k]; } };
+	    }
+	    Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    o[k2] = m[k];
+	}));
+	var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	// Deprecated shim to preserve v30 namespace names
+	__exportStar(events, exports); 
+} (OpenFin$2));
+
+var OpenFin = /*@__PURE__*/getDefaultExportFromCjs(OpenFin$2);
+
+var OpenFin$1 = /*#__PURE__*/_mergeNamespaces({
+	__proto__: null,
+	default: OpenFin
+}, [OpenFin$2]);
+
+var fin$2 = {};
+
+var system = {};
+
+var base = {};
+
+var promises = {};
+
+Object.defineProperty(promises, "__esModule", { value: true });
+promises.promiseMapSerial = promises.serial = promises.promiseMap = promises.promisify = void 0;
+function promisify(func) {
+    return (...args) => new Promise((resolve, reject) => {
+        func(...args, (err, val) => (err ? reject(err) : resolve(val)));
+    });
+}
+promises.promisify = promisify;
+async function promiseMap(arr, asyncF) {
+    return Promise.all(arr.map(asyncF));
+}
+promises.promiseMap = promiseMap;
+async function serial(arr) {
+    const ret = [];
+    for (const func of arr) {
+        // eslint-disable-next-line no-await-in-loop
+        const next = await func();
+        ret.push(next);
+    }
+    return ret;
+}
+promises.serial = serial;
+async function promiseMapSerial(arr, func) {
+    return serial(arr.map((value, index, array) => () => func(value, index, array)));
+}
+promises.promiseMapSerial = promiseMapSerial;
+
+var __classPrivateFieldSet$c = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet$e = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _EmitterBase_emitterAccessor;
+Object.defineProperty(base, "__esModule", { value: true });
+base.Reply = base.EmitterBase = base.Base = void 0;
+const promises_1 = promises;
+class Base {
+    /**
+     * @internal
+     */
+    constructor(wire) {
+        /**
+         * @internal
+         * @deprecated
+         */
+        this.isNodeEnvironment = () => {
+            return this.wire.environment.type === 'node';
+        };
+        /**
+         * @internal
+         * @deprecated
+         */
+        this.isOpenFinEnvironment = () => {
+            return this.wire.environment.type === 'openfin';
+        };
+        /**
+         * @internal
+         * @deprecated
+         */
+        this.isBrowserEnvironment = () => {
+            return this.wire.environment.type === 'other';
+        };
+        this.wire = wire;
+    }
+    get fin() {
+        return this.wire.getFin();
+    }
+    /**
+     * Provides access to the OpenFin representation of the current code context (usually a document
+     * such as a {@link OpenFin.View} or {@link OpenFin.Window}), as well as to the current `Interop` context.
+     *
+     * Useful for debugging in the devtools console, where this will intelligently type itself based
+     * on the context in which the devtools panel was opened.
+     */
+    get me() {
+        return this.wire.me;
+    }
+}
+base.Base = Base;
+/**
+ * An entity that emits OpenFin events.
+ *
+ * @remarks Event-binding methods are asynchronous as they must cross process boundaries
+ * and setup the listener in the browser process.  When the `EventEmitter` receives an event from the browser process
+ * and emits on the renderer, all of the functions attached to that specific event are called synchronously.  Any values
+ * returned by the called listeners are ignored and will be discarded.  If the execution context of the window is destroyed
+ * by page navigation or reload, any events that have been setup in that context will be destroyed.
+ *
+ * It is important to keep in mind that when an ordinary listener function is called, the standard `this` keyword is intentionally
+ * set to reference the `EventEmitter` instance to which the listener is attached.  It is possible to use ES6 Arrow Functions as
+ * listeners, however, when doing so, the `this` keyword will no longer reference the `EventEmitter` instance.
+ *
+ * Events re-propagate from smaller/more-local scopes to larger/more-global scopes.  For example, an event emitted on a specific
+ * view will propagate to the window in which the view is embedded, and then to the application in which the window is running, and
+ * finally to the OpenFin runtime itself at the "system" level.  Re-propagated events are prefixed with the name of the scope in which
+ * they originated - for example, a "shown" event emitted on a view will be re-propagated at the window level as "view-shown", and
+ * then to the application as "window-view-shown", and finally at the system level as "application-window-view-shown".
+ *
+ * All event propagations are visible at the System level, regardless of source, so transitive re-propagations (e.g. from view to window
+ * to application) are visible in their entirety at the system level.  So, we can listen to the above event as "shown", "view-shown",
+ * "window-view-shown", or "application-window-view-shown."
+ */
+class EmitterBase extends Base {
+    constructor(wire, topic, ...additionalAccessors) {
+        super(wire);
+        this.topic = topic;
+        _EmitterBase_emitterAccessor.set(this, void 0);
+        this.eventNames = () => (this.hasEmitter() ? this.getOrCreateEmitter().eventNames() : []);
+        /**
+         * @internal
+         */
+        this.emit = (eventType, payload, ...args) => {
+            return this.hasEmitter() ? this.getOrCreateEmitter().emit(eventType, payload, ...args) : false;
+        };
+        this.hasEmitter = () => this.wire.eventAggregator.has(__classPrivateFieldGet$e(this, _EmitterBase_emitterAccessor, "f"));
+        this.getOrCreateEmitter = () => this.wire.eventAggregator.getOrCreate(__classPrivateFieldGet$e(this, _EmitterBase_emitterAccessor, "f"));
+        this.listeners = (type) => this.hasEmitter() ? this.getOrCreateEmitter().listeners(type) : [];
+        this.listenerCount = (type) => this.hasEmitter() ? this.getOrCreateEmitter().listenerCount(type) : 0;
+        this.registerEventListener = async (eventType, options = {}, applySubscription, undoSubscription) => {
+            const runtimeEvent = {
+                ...this.identity,
+                timestamp: options.timestamp || Date.now(),
+                topic: this.topic,
+                type: eventType
+            };
+            const emitter = this.getOrCreateEmitter();
+            // We apply the subscription and then undo if the async call fails to avoid
+            // indeterminacy in subscription application order, which can break things elsewhere
+            applySubscription(emitter);
+            try {
+                await this.wire.sendAction('subscribe-to-desktop-event', runtimeEvent);
+            }
+            catch (e) {
+                undoSubscription(emitter);
+                this.deleteEmitterIfNothingRegistered(emitter);
+                throw e;
+            }
+        };
+        this.deregisterEventListener = async (eventType, options = {}) => {
+            if (this.hasEmitter()) {
+                const runtimeEvent = {
+                    ...this.identity,
+                    timestamp: options.timestamp || Date.now(),
+                    topic: this.topic,
+                    type: eventType
+                };
+                await this.wire.sendAction('unsubscribe-to-desktop-event', runtimeEvent).catch(() => null);
+                const emitter = this.getOrCreateEmitter();
+                return emitter;
+            }
+            // This will only be reached if unsubscribe from event that does not exist but do not want to error here
+            return Promise.resolve();
+        };
+        __classPrivateFieldSet$c(this, _EmitterBase_emitterAccessor, [topic, ...additionalAccessors], "f");
+        this.listeners = (event) => this.hasEmitter() ? this.getOrCreateEmitter().listeners(event) : [];
+    }
+    /**
+     * Adds a listener to the end of the listeners array for the specified event.
+     *
+     * @remarks Event payloads are documented in the {@link OpenFin.Events} namespace.
+     */
+    async on(eventType, listener, options) {
+        await this.registerEventListener(eventType, options, (emitter) => {
+            emitter.on(eventType, listener);
+        }, (emitter) => {
+            emitter.removeListener(eventType, listener);
+        });
+        return this;
+    }
+    /**
+     * Adds a listener to the end of the listeners array for the specified event.
+     */
+    async addListener(eventType, listener, options) {
+        return this.on(eventType, listener, options);
+    }
+    /**
+     * Adds a one time listener for the event. The listener is invoked only the first time the event is fired, after which it is removed.
+     *
+     * @remarks Event payloads are documented in the {@link OpenFin.Events} namespace.
+     */
+    async once(eventType, listener, options) {
+        const deregister = () => this.deregisterEventListener(eventType);
+        await this.registerEventListener(eventType, options, (emitter) => {
+            emitter.once(eventType, deregister);
+            emitter.once(eventType, listener);
+        }, (emitter) => {
+            emitter.removeListener(eventType, deregister);
+            emitter.removeListener(eventType, listener);
+        });
+        return this;
+    }
+    /**
+     * Adds a listener to the beginning of the listeners array for the specified event.
+     *
+     * @remarks Event payloads are documented in the {@link OpenFin.Events} namespace.
+     */
+    async prependListener(eventType, listener, options) {
+        await this.registerEventListener(eventType, options, (emitter) => {
+            emitter.prependListener(eventType, listener);
+        }, (emitter) => {
+            emitter.removeListener(eventType, listener);
+        });
+        return this;
+    }
+    /**
+     * Adds a one time listener for the event. The listener is invoked only the first time the event is fired,
+     * after which it is removed. The listener is added to the beginning of the listeners array.
+     *
+     * @remarks Event payloads are documented in the {@link OpenFin.Events} namespace.
+     */
+    async prependOnceListener(eventType, listener, options) {
+        const deregister = () => this.deregisterEventListener(eventType);
+        await this.registerEventListener(eventType, options, (emitter) => {
+            emitter.prependOnceListener(eventType, listener);
+            emitter.once(eventType, deregister);
+        }, (emitter) => {
+            emitter.removeListener(eventType, listener);
+            emitter.removeListener(eventType, deregister);
+        });
+        return this;
+    }
+    /**
+     * Remove a listener from the listener array for the specified event.
+     *
+     * @remarks Caution: Calling this method changes the array indices in the listener array behind the listener.
+     */
+    async removeListener(eventType, listener, options) {
+        const emitter = await this.deregisterEventListener(eventType, options);
+        if (emitter) {
+            emitter.removeListener(eventType, listener);
+            this.deleteEmitterIfNothingRegistered(emitter);
+        }
+        return this;
+    }
+    async deregisterAllListeners(eventType) {
+        const runtimeEvent = { ...this.identity, type: eventType, topic: this.topic };
+        if (this.hasEmitter()) {
+            const emitter = this.getOrCreateEmitter();
+            const refCount = emitter.listenerCount(runtimeEvent.type);
+            const unsubscribePromises = [];
+            for (let i = 0; i < refCount; i++) {
+                unsubscribePromises.push(this.wire.sendAction('unsubscribe-to-desktop-event', runtimeEvent).catch(() => null));
+            }
+            await Promise.all(unsubscribePromises);
+            return emitter;
+        }
+        return undefined;
+    }
+    /**
+     * Removes all listeners, or those of the specified event.
+     *
+     */
+    async removeAllListeners(eventType) {
+        const removeByEvent = async (event) => {
+            const emitter = await this.deregisterAllListeners(event);
+            if (emitter) {
+                emitter.removeAllListeners(event);
+                this.deleteEmitterIfNothingRegistered(emitter);
+            }
+        };
+        if (eventType) {
+            await removeByEvent(eventType);
+        }
+        else if (this.hasEmitter()) {
+            const events = this.getOrCreateEmitter().eventNames();
+            await (0, promises_1.promiseMap)(events, removeByEvent);
+        }
+        return this;
+    }
+    deleteEmitterIfNothingRegistered(emitter) {
+        if (emitter.eventNames().length === 0) {
+            this.wire.eventAggregator.delete(__classPrivateFieldGet$e(this, _EmitterBase_emitterAccessor, "f"));
+        }
+    }
+}
+base.EmitterBase = EmitterBase;
+_EmitterBase_emitterAccessor = new WeakMap();
+class Reply {
+}
+base.Reply = Reply;
+
+var transportErrors = {};
+
+Object.defineProperty(transportErrors, "__esModule", { value: true });
+transportErrors.RuntimeError = transportErrors.NotSupportedError = transportErrors.NotImplementedError = transportErrors.NoAckError = transportErrors.DuplicateCorrelationError = transportErrors.UnexpectedActionError = transportErrors.DisconnectedError = void 0;
+class DisconnectedError extends Error {
+    constructor(readyState) {
+        super(`Expected websocket state OPEN but found ${readyState}`);
+        this.readyState = readyState;
+    }
+}
+transportErrors.DisconnectedError = DisconnectedError;
+class UnexpectedActionError extends Error {
+}
+transportErrors.UnexpectedActionError = UnexpectedActionError;
+class DuplicateCorrelationError extends Error {
+}
+transportErrors.DuplicateCorrelationError = DuplicateCorrelationError;
+class NoAckError extends Error {
+}
+transportErrors.NoAckError = NoAckError;
+class NotImplementedError extends Error {
+}
+transportErrors.NotImplementedError = NotImplementedError;
+class NotSupportedError extends Error {
+}
+transportErrors.NotSupportedError = NotSupportedError;
+class InternalError extends Error {
+    constructor(err) {
+        const { message, name, stack, ...rest } = err;
+        super(message);
+        this.name = name || 'Error';
+        this.stack = stack ?? this.toString();
+        Object.keys(rest).forEach(key => {
+            this[key] = rest[key];
+        });
+    }
+}
+// For documentation of the error methods being used see here: https://v8.dev/docs/stack-trace-api
+class RuntimeError extends Error {
+    static getCallSite(callsToRemove = 0) {
+        const length = Error.stackTraceLimit;
+        const realCallsToRemove = callsToRemove + 1; // remove this call;
+        Error.stackTraceLimit = length + realCallsToRemove;
+        // eslint-disable-next-line no-underscore-dangle
+        const _prepareStackTrace = Error.prepareStackTrace;
+        // This will be called when we access the `stack` property
+        Error.prepareStackTrace = (_, stack) => stack;
+        // stack is optional in non chromium contexts
+        const stack = new Error().stack?.slice(realCallsToRemove) ?? [];
+        Error.prepareStackTrace = _prepareStackTrace;
+        Error.stackTraceLimit = length;
+        return stack;
+    }
+    static prepareStackTrace(err, callSites) {
+        if (typeof Error.prepareStackTrace === 'function') {
+            return Error.prepareStackTrace(err, callSites);
+        }
+        let string = "";
+        string += err.name || "Error";
+        string += `: ${err.message || ""}`;
+        for (const callSite of callSites) {
+            string += `\n    at ${callSite.toString()}`;
+        }
+        return string;
+    }
+    ;
+    constructor(payload, callSites) {
+        const { reason, error } = payload;
+        super(reason);
+        this.name = 'RuntimeError';
+        if (error?.stack) {
+            this.cause = new InternalError(error);
+        }
+        if (callSites) {
+            this.stack = RuntimeError.prepareStackTrace(this, callSites);
+        }
+    }
+}
+transportErrors.RuntimeError = RuntimeError;
+
+var window$1 = {};
+
+var Factory$8 = {};
+
+var validate = {};
+
+Object.defineProperty(validate, "__esModule", { value: true });
+validate.validateIdentity = void 0;
+function validateIdentity(identity) {
+    let errorMsg;
+    if (typeof identity !== 'object' || typeof identity.uuid !== 'string') {
+        errorMsg = 'Not a valid identity object';
+    }
+    return errorMsg;
+}
+validate.validateIdentity = validateIdentity;
+
+var Instance$7 = {};
+
+var application = {};
+
+var Factory$7 = {};
+
+var Instance$6 = {};
+
+var view = {};
+
+var Factory$6 = {};
+
+var warnings = {};
+
+Object.defineProperty(warnings, "__esModule", { value: true });
+warnings.handleDeprecatedWarnings = void 0;
+const handleDeprecatedWarnings = (options) => {
+    if (options.contentNavigation?.whitelist ||
+        options.contentNavigation?.blacklist ||
+        options.contentRedirect?.whitelist ||
+        options.contentRedirect?.blacklist) {
+        console.warn(`The properties 'whitelist' and 'blacklist' have been marked as deprecated and will be removed in a future version. Please use 'allowlist' and 'denylist'.`);
+    }
+};
+warnings.handleDeprecatedWarnings = handleDeprecatedWarnings;
+
+var hasRequiredFactory$3;
+
+function requireFactory$3 () {
+	if (hasRequiredFactory$3) return Factory$6;
+	hasRequiredFactory$3 = 1;
+	Object.defineProperty(Factory$6, "__esModule", { value: true });
+	Factory$6.ViewModule = void 0;
+	const base_1 = base;
+	const validate_1 = validate;
+	const index_1 = requireView();
+	const warnings_1 = warnings;
+	/**
+	 * Static namespace for OpenFin API methods that interact with the {@link View} class, available under `fin.View`.
+	 */
+	class ViewModule extends base_1.Base {
+	    /**
+	     * Creates a new View.
+	     * @param options - View creation options
+	     *
+	     * @example
+	     * ```js
+	     * let view;
+	     * async function createView() {
+	     *     const me = await fin.Window.getCurrent();
+	     *     return fin.View.create({
+	     *         name: 'viewNameCreate',
+	     *         target: me.identity,
+	     *         bounds: {top: 10, left: 10, width: 200, height: 200}
+	     *     });
+	     * }
+	     *
+	     * createView()
+	     *     .then((createdView) => {
+	     *         view = createdView;
+	     *         console.log('View created.', view);
+	     *         view.navigate('https://google.com');
+	     *         console.log('View navigated to given url.');
+	     *     })
+	     *     .catch(err => console.log(err));
+	     * ```
+	     * Note that created views needs to navigate somewhere for them to actually render a website.
+	     * @experimental
+	     */
+	    async create(options) {
+	        const { uuid } = this.wire.me;
+	        if (!options.name || typeof options.name !== 'string') {
+	            throw new Error('Please provide a name property as a string in order to create a View.');
+	        }
+	        (0, warnings_1.handleDeprecatedWarnings)(options);
+	        if (this.wire.environment.childViews) {
+	            await this.wire.environment.createChildContent({
+	                entityType: 'view',
+	                options: { ...options, uuid }
+	            });
+	        }
+	        else {
+	            await this.wire.sendAction('create-view', { ...options, uuid });
+	        }
+	        return this.wrapSync({ uuid, name: options.name });
+	    }
+	    /**
+	     * Asynchronously returns an API handle for the given View identity.
+	     *
+	     * @remarks Wrapping a View identity that does not yet exist will *not* throw an error, and instead
+	     * returns a stub object that cannot yet perform rendering tasks. This can be useful for plumbing eventing
+	     * for a View throughout its entire lifecycle.
+	     *
+	     * @example
+	     * ```js
+	     * fin.View.wrap({ uuid: 'testViewUuid', name: 'testViewName' }))
+	     *     .then(view => console.log('wrapped view', view))
+	     *     .catch(err => console.log(err));
+	     * ```
+	     * @experimental
+	     */
+	    async wrap(identity) {
+	        this.wire.sendAction('view-wrap').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        const errorMsg = (0, validate_1.validateIdentity)(identity);
+	        if (errorMsg) {
+	            throw new Error(errorMsg);
+	        }
+	        return new index_1.View(this.wire, identity);
+	    }
+	    /**
+	     * Synchronously returns an API handle for the given View identity.
+	     *
+	     * @remarks Wrapping a View identity that does not yet exist will *not* throw an error, and instead
+	     * returns a stub object that cannot yet perform rendering tasks. This can be useful for plumbing eventing
+	     * for a View throughout its entire lifecycle.
+	     *
+	     * @example
+	     * ```js
+	     * const view = fin.View.wrapSync({ uuid: 'testView', name: 'testViewName' });
+	     * await view.hide();
+	     * ```
+	     * @experimental
+	     */
+	    wrapSync(identity) {
+	        this.wire.sendAction('view-wrap-sync').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        const errorMsg = (0, validate_1.validateIdentity)(identity);
+	        if (errorMsg) {
+	            throw new Error(errorMsg);
+	        }
+	        return new index_1.View(this.wire, identity);
+	    }
+	    /**
+	     * Asynchronously returns a View object that represents the current view
+	     *
+	     * @example
+	     * ```js
+	     * fin.View.getCurrent()
+	     *     .then(view => console.log('current view', view))
+	     *     .catch(err => console.log(err));
+	     *
+	     * ```
+	     * @experimental
+	     */
+	    getCurrent() {
+	        this.wire.sendAction('view-get-current').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        if (!this.wire.me.isView) {
+	            throw new Error('You are not in a View context');
+	        }
+	        const { uuid, name } = this.wire.me;
+	        return this.wrap({ uuid, name });
+	    }
+	    /**
+	     * Synchronously returns a View object that represents the current view
+	     *
+	     * @example
+	     * ```js
+	     * const view = fin.View.getCurrentSync();
+	     * console.log(view);
+	     *
+	     * ```
+	     * @experimental
+	     */
+	    getCurrentSync() {
+	        this.wire.sendAction('view-get-current-sync').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        if (!this.wire.me.isView) {
+	            throw new Error('You are not in a View context');
+	        }
+	        const { uuid, name } = this.wire.me;
+	        return this.wrapSync({ uuid, name });
+	    }
+	}
+	Factory$6.ViewModule = ViewModule;
+	return Factory$6;
+}
+
+var Instance$5 = {};
+
+var lazy = {};
+
+Object.defineProperty(lazy, "__esModule", { value: true });
+lazy.AsyncRetryableLazy = lazy.Lazy = void 0;
+/**
+ * Handy class for managing asynchronous dependencies of classes.
+ *
+ * Will call the producer function once and only once when getValue is called,
+ * returning the resultant value for every subsequent call.
+ */
+class Lazy {
+    // eslint-disable-next-line
+    constructor(producerFn) {
+        this.producerFn = producerFn;
+    }
+    /**
+     * Lazily get the value returned by the producer.
+     * @returns The value returned from the producer function
+     */
+    getValue() {
+        if (!this.value) {
+            this.value = this.producerFn();
+        }
+        return this.value;
+    }
+}
+lazy.Lazy = Lazy;
+/**
+ * Handy class for managing asynchronous dependencies of classes.
+ *
+ * Will call asynchronous producer only after `getValue` is called.  If the
+ * deferred code errors, we can try it again by re-calling `getValue` after
+ * the promise rejects.
+ */
+class AsyncRetryableLazy {
+    // eslint-disable-next-line
+    constructor(producerFn) {
+        this.producerFn = producerFn;
+    }
+    /**
+     * Lazily get the value returned by the async producer.
+     *
+     * @returns The value returned from the producer function
+     */
+    async getValue() {
+        if (!this.promise) {
+            this.promise = this.producerFn().catch((e) => {
+                delete this.promise;
+                throw e;
+            });
+        }
+        return this.promise;
+    }
+}
+lazy.AsyncRetryableLazy = AsyncRetryableLazy;
+
+var layoutEntities = {};
+
+var apiExposer$1 = {};
+
+var apiConsumer = {};
+
+Object.defineProperty(apiConsumer, "__esModule", { value: true });
+apiConsumer.ApiConsumer = void 0;
+/**
+ * Consumer for apis exposed with {@see ApiExposer}.
+ *
+ * A strategy that matches the strategy used to expose a target API must be provided.
+ */
+class ApiConsumer {
+    // eslint-disable-next-line
+    constructor(strategy) {
+        this.strategy = strategy;
+        /**
+         * Consumes an api exposed using a given transport strategy, and generates a client
+         * for easy, type safe consumption of that client.
+         * @param options Strategy specific consumption options.
+         * @returns An api client matching the given type.
+         */
+        this.consume = async (options) => {
+            const exposedProperties = await this.strategy.getExposedFunctions(options);
+            return exposedProperties.reduce((client, prop) => ({
+                ...client,
+                [prop.key]: this.strategy.createFunction(prop, options)
+            }), {});
+        };
+    }
+}
+apiConsumer.ApiConsumer = ApiConsumer;
+
+var apiExposer = {};
+
+var decorators = {};
+
+Object.defineProperty(decorators, "__esModule", { value: true });
+decorators.expose = decorators.getExposedProperties = void 0;
+const exposedProperties = Symbol('exposedProperties');
+const getExposedProperties = (target) => {
+    return target[exposedProperties] || target.prototype[exposedProperties] || [];
+};
+decorators.getExposedProperties = getExposedProperties;
+/**
+ * Indicates that a class member function can be exposed using {@link ApiExposer}.
+ * @param options Options specific to the strategy used in {@link ApiExposer}
+ */
+// Returns any as decorator typing is weird.
+const expose = (options) => (target, key, descriptor) => {
+    target[exposedProperties] = target[exposedProperties] || [];
+    target[exposedProperties].push({ key, descriptor, options });
+};
+decorators.expose = expose;
+
+Object.defineProperty(apiExposer, "__esModule", { value: true });
+apiExposer.ApiExposer = void 0;
+const decorators_1 = decorators;
+/**
+ * Exposes api services on the transport of choice.
+ */
+class ApiExposer {
+    /**
+     * @param strategy The expose strategy to use to expose instances.
+     */
+    // eslint-disable-next-line
+    constructor(strategy) {
+        this.strategy = strategy;
+        /**
+         * Exposes an instance of a given api on
+         * @param instance Instance of a class which has been decorated to indicate which functions can be exposed.
+         * @param instanceOptions Transport strategy specific options to use when exposing.
+         */
+        this.exposeInstance = async (instance, instanceOptions) => {
+            const exposableProps = (0, decorators_1.getExposedProperties)(instance);
+            const exposedProps = await Promise.all(exposableProps.map(async ({ key, options }) => {
+                const customConsumptionOptions = await this.strategy.exposeFunction(instance[key].bind(instance), {
+                    key,
+                    options,
+                    meta: instanceOptions
+                });
+                return {
+                    key,
+                    options: customConsumptionOptions
+                };
+            }));
+            await this.strategy.exposeMeta(instanceOptions, exposedProps);
+        };
+    }
+    ;
+}
+apiExposer.ApiExposer = ApiExposer;
+
+var strategies = {};
+
+var openfinChannels = {};
+
+var channelsConsumer = {};
+
+Object.defineProperty(channelsConsumer, "__esModule", { value: true });
+channelsConsumer.ChannelsConsumer = void 0;
+class ChannelsConsumer {
+    // eslint-disable-next-line
+    constructor(channel) {
+        this.channel = channel;
+        this.getExposedFunctions = async (options) => {
+            const { id } = options;
+            const { props } = await this.channel.dispatch(`api-meta:${id}`);
+            return props;
+        };
+        this.createFunction = (prop) => (...args) => {
+            const { action } = prop.options;
+            return this.channel.dispatch(action, { args });
+        };
+    }
+    ;
+}
+channelsConsumer.ChannelsConsumer = ChannelsConsumer;
+
+var channelsExposer = {};
+
+Object.defineProperty(channelsExposer, "__esModule", { value: true });
+channelsExposer.ChannelsExposer = void 0;
+class ChannelsExposer {
+    // eslint-disable-next-line
+    constructor(channelProviderOrClient) {
+        this.channelProviderOrClient = channelProviderOrClient;
+        this.exposeFunction = async (target, config) => {
+            const { key, options, meta } = config;
+            const { id } = meta;
+            const action = `${id}.${options?.action || key}`;
+            await this.channelProviderOrClient.register(action, async ({ args }) => {
+                return target(...args);
+            });
+            return { action };
+        };
+        this.exposeMeta = async ({ id }, props) => {
+            const action = `api-meta:${id}`;
+            await this.channelProviderOrClient.register(action, () => ({ props }));
+        };
+    }
+}
+channelsExposer.ChannelsExposer = ChannelsExposer;
+
+(function (exports) {
+	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    var desc = Object.getOwnPropertyDescriptor(m, k);
+	    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+	      desc = { enumerable: true, get: function() { return m[k]; } };
+	    }
+	    Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    o[k2] = m[k];
+	}));
+	var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	__exportStar(channelsConsumer, exports);
+	__exportStar(channelsExposer, exports); 
+} (openfinChannels));
+
+(function (exports) {
+	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    var desc = Object.getOwnPropertyDescriptor(m, k);
+	    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+	      desc = { enumerable: true, get: function() { return m[k]; } };
+	    }
+	    Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    o[k2] = m[k];
+	}));
+	var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	__exportStar(openfinChannels, exports); 
+} (strategies));
+
+(function (exports) {
+	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    var desc = Object.getOwnPropertyDescriptor(m, k);
+	    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+	      desc = { enumerable: true, get: function() { return m[k]; } };
+	    }
+	    Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    o[k2] = m[k];
+	}));
+	var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	__exportStar(apiConsumer, exports);
+	__exportStar(apiExposer, exports);
+	__exportStar(strategies, exports);
+	__exportStar(decorators, exports); 
+} (apiExposer$1));
+
+var channelApiRelay = {};
+
+Object.defineProperty(channelApiRelay, "__esModule", { value: true });
+channelApiRelay.createRelayedDispatch = channelApiRelay.relayChannelClientApi = void 0;
+const EXPECTED_ERRORS = [
+    'no longer connected',
+    'RTCDataChannel closed unexpectedly',
+    'The client you are trying to dispatch from is disconnected from the target provider',
+];
+// Checks possible error messages that we want to trap, client error message can originate
+// from ChannelProvider::dispatch OR ClassicStrategy::closeEndpoint OR RTCEndPoint::dataChannel::onclose
+const isDisconnectedError = (errorMsg) => {
+    return EXPECTED_ERRORS.some(e => errorMsg.includes(e));
+};
+/**
+ * @internal
+ * Create a channel relay for a given channel exposition, allowing a single provider to route
+ * actions to the designated clients.
+ *
+ * Designed to be used in conjunction with @expose
+ *
+ * @param channelProvider The channel provider to relay the actions on.
+ * @param config Determines which actions to relay. Please ensure action prefix matches the exposed api.
+ */
+const relayChannelClientApi = async (channelProvider, relayId) => {
+    channelProvider.register(`relay:${relayId}`, ({ action, target, payload }) => {
+        return channelProvider.dispatch(target, action, payload);
+    });
+    await Promise.resolve();
+};
+channelApiRelay.relayChannelClientApi = relayChannelClientApi;
+const createRelayedDispatch = (client, target, relayId, relayErrorMsg) => async (action, payload) => {
+    try {
+        return await client.dispatch(`relay:${relayId}`, {
+            action,
+            payload,
+            target
+        });
+    }
+    catch (e) {
+        if (isDisconnectedError(e.message) && relayErrorMsg) {
+            throw new Error(relayErrorMsg);
+        }
+        throw e;
+    }
+};
+channelApiRelay.createRelayedDispatch = createRelayedDispatch;
+
+var __classPrivateFieldSet$b = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet$d = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _LayoutNode_client, _TabStack_client, _ColumnOrRow_client;
+Object.defineProperty(layoutEntities, "__esModule", { value: true });
+layoutEntities.ColumnOrRow = layoutEntities.TabStack = layoutEntities.LayoutNode = void 0;
+const api_exposer_1 = apiExposer$1;
+const channel_api_relay_1 = channelApiRelay;
+/*
+    This file includes LayoutNode, ColumnOrRow and TabStack classes, which are all closely
+    intertwined, and share members via parent abstract class LayoutNode. To prevent circular
+    refs, we define and export all the classes here.
+*/
+/**
+ * @ignore
+ * @internal
+ * Supplies an ApiClient for {@link LayoutEntitiesController} and helper methods
+ * for the entities {@link TabStack} AND {@link ColumnOrRow} to use.
+ */
+class LayoutNode {
+    /**
+     * @internal
+     * @ignore
+     */
+    constructor(client, entityId) {
+        /**
+         * @ignore
+         * @internal
+         * ApiClient for {@link LayoutEntitiesController}
+         */
+        _LayoutNode_client.set(this, void 0);
+        /**
+         * Checks if the TabStack or ColumnOrRow is the root content item
+         *
+         * @example
+         * ```js
+         * if (!fin.me.isView) {
+         *     throw new Error('Not running in a platform View.');
+         * }
+         *
+         * const stack = await fin.me.getCurrentStack();
+         * const isRoot = await stack.isRoot();
+         * // The TabStack is root: false
+         * console.log(`The TabStack is root: ${isRoot}`);
+         *
+         * // Retrieves the parent ColumnOrRow
+         * const parent = await stack.getParent();
+         * const parentIsRoot = await parent.isRoot();
+         * // The parent ColumnOrRow is root: true
+         * console.log(`The parent ColumnOrRow is root: ${parentIsRoot}`);
+         * ```
+         */
+        this.isRoot = () => __classPrivateFieldGet$d(this, _LayoutNode_client, "f").isRoot(this.entityId);
+        /**
+         * Checks if the TabStack or ColumnOrRow exists
+         *
+         * @example
+         * ```js
+         * if (!fin.me.isView) {
+         *     throw new Error('Not running in a platform View.');
+         * }
+         *
+         * const stack = await fin.me.getCurrentStack();
+         * // Retrieves the parent ColumnOrRow
+         * const columnOrRow = await stack.getParent();
+         * let exists = await stack.exists();
+         * // or
+         * let exists = await columnOrRow.exists();
+         * // The entity exists: true
+         * console.log(`The entity exists: ${exists}`);
+         * ```
+         */
+        this.exists = () => __classPrivateFieldGet$d(this, _LayoutNode_client, "f").exists(this.entityId);
+        /**
+         * Retrieves the parent of the TabStack or ColumnOrRow
+         *
+         * @example
+         * ```js
+         * if (!fin.me.isView) {
+         *     throw new Error('Not running in a platform View.');
+         * }
+         *
+         * const stack = await fin.me.getCurrentStack();
+         * // Retrieves the parent ColumnOrRow
+         * const columnOrRow = await stack.getParent();
+         *
+         * // undefined if entity is the root item
+         * let parent = await columnOrRow.getParent();
+         * // or
+         * let parent = await stack.getParent();
+         * ```
+         */
+        this.getParent = async () => {
+            const parent = await __classPrivateFieldGet$d(this, _LayoutNode_client, "f").getParent(this.entityId);
+            if (!parent) {
+                return undefined;
+            }
+            return LayoutNode.getEntity(parent, __classPrivateFieldGet$d(this, _LayoutNode_client, "f"));
+        };
+        /**
+         * Creates a new TabStack adjacent to the given TabStack or ColumnOrRow. Inputs can be new views to create, or existing views.
+         *
+         * Known Issue: If the number of views to add overflows the tab-container, the added views will be set as active
+         * during each render, and then placed at the front of the tab-stack, while the underlying order of tabs will remain unchanged.
+         * This means the views you pass to createAdjacentStack() may not render in the order given by the array.
+         * Until fixed, this problem can be avoided only if your window is wide enough to fit creating all the views in the tabstack.
+         *
+         * @param views The views that will populate the new TabStack.
+         * @param options Additional options that control new TabStack creation.
+         * @returns The newly-created TabStack.
+         *
+         * @example
+         * ```js
+         * if (!fin.me.isView) {
+         *     throw new Error('Not running in a platform View.');
+         * }
+         *
+         * const stack = await fin.me.getCurrentStack();
+         * const columnOrRow = await stack.getParent();
+         *
+         * // Create view references by supplying a 'name' and 'url'
+         * const views = [
+         *     // if 'name' is undefined, one will be generated
+         *     // if 'url' is undefined, it will default the view URL to 'about:blank'
+         *     { name: 'google-view', url: 'http://google.com/'},
+         *     { name: 'of-developers-view', url: 'http://developers.openfin.co/'},
+         * ];
+         *
+         * // Create a view beforehand to be included in the new tab stack
+         * const outsideView = await fin.View.create({
+         *     name: 'outside-bloomberg-view',
+         *     url: 'https://bloomberg.com/',
+         *     target: fin.me.identity,
+         * });
+         *
+         * // Views to add can be identities, or the reference views mentioned above
+         * const viewsToAdd = [outsideView.identity, ...views];
+         *
+         * // Possible position inputs: 'right' | 'left' | 'top' | 'bottom'
+         * let stackFrom = await columnOrRow.createAdjacentStack(viewsToAdd, { position: 'right' });
+         * // Or
+         * let newStack = await stack.createAdjacentStack(viewsToAdd, { position: 'right' });
+         * console.log(`A new TabStack created to the right has ${newStack.length} views in it`);
+         *
+         * ```
+         * @experimental
+         */
+        this.createAdjacentStack = async (views, options) => {
+            const entityId = await __classPrivateFieldGet$d(this, _LayoutNode_client, "f").createAdjacentStack(this.entityId, views, options);
+            return LayoutNode.getEntity({ entityId, type: 'stack' }, __classPrivateFieldGet$d(this, _LayoutNode_client, "f"));
+        };
+        /**
+         * Retrieves the adjacent TabStacks of the given TabStack or ColumnOrRow.
+         *
+         * @param edge Edge whose adjacent TabStacks will be returned.
+         *
+         * @example
+         * ```js
+         * if (!fin.me.isView) {
+         *     throw new Error('Not running in a platform View.');
+         * }
+         *
+         * const stack = await fin.me.getCurrentStack();
+         * const columnOrRow = await stack.getParent();
+         * // Possible position inputs: 'right' | 'left' | 'top' | 'bottom'
+         * let rightStacks = await columnOrRow.getAdjacentStacks('right');
+         * let leftStacks = await columnOrRow.getAdjacentStacks('left');
+         * // or
+         * let rightStacks = await stack.getAdjacentStacks('right');
+         * let leftStacks = await stack.getAdjacentStacks('left');
+         *
+         * console.log(`The entity has ${rightStacks.length} stacks to the right, and ${leftStacks.length} stacks to the left`);
+         *
+         * ```
+         * @experimental
+         */
+        this.getAdjacentStacks = async (edge) => {
+            const adjacentStacks = await __classPrivateFieldGet$d(this, _LayoutNode_client, "f").getAdjacentStacks({
+                targetId: this.entityId,
+                edge
+            });
+            return adjacentStacks.map((stack) => LayoutNode.getEntity({
+                type: 'stack',
+                entityId: stack.entityId
+            }, __classPrivateFieldGet$d(this, _LayoutNode_client, "f")));
+        };
+        __classPrivateFieldSet$b(this, _LayoutNode_client, client, "f");
+        this.entityId = entityId;
+    }
+}
+layoutEntities.LayoutNode = LayoutNode;
+_LayoutNode_client = new WeakMap();
+/**
+ * @ignore
+ * @internal
+ * Encapsulates Api consumption of {@link LayoutEntitiesClient} with a relayed dispatch
+ * @param client
+ * @param controllerId
+ * @param identity
+ * @returns a new instance of {@link LayoutEntitiesClient} with bound to the controllerId
+ */
+LayoutNode.newLayoutEntitiesClient = async (client, controllerId, identity) => {
+    const dispatch = (0, channel_api_relay_1.createRelayedDispatch)(client, identity, 'layout-relay', 'You are trying to interact with a layout component on a window that does not exist or has been destroyed.');
+    const consumer = new api_exposer_1.ApiConsumer(new api_exposer_1.ChannelsConsumer({ dispatch }));
+    return consumer.consume({ id: controllerId });
+};
+LayoutNode.getEntity = (definition, client) => {
+    const { entityId, type } = definition;
+    switch (type) {
+        case 'column':
+        case 'row':
+            return new ColumnOrRow(client, entityId, type);
+        case 'stack':
+            return new TabStack(client, entityId);
+        default:
+            throw new Error(`Unrecognised Layout Entity encountered ('${JSON.stringify(definition)})`);
+    }
+};
+/**
+ * A TabStack is used to manage the state of a stack of tabs within an OpenFin Layout.
+ */
+class TabStack extends LayoutNode {
+    /** @internal */
+    constructor(client, entityId) {
+        super(client, entityId);
+        /**
+         * @internal
+         * ApiClient for {@link LayoutEntitiesController}
+         */
+        _TabStack_client.set(this, void 0);
+        /**
+         * Type of the content item. Always stack, but useful for distinguishing between a {@link TabStack} and {@link ColumnOrRow}.
+         */
+        this.type = 'stack';
+        /**
+         * Retrieves a list of all views belonging to this {@link TabStack}.
+         *
+         * Known Issue: If adding a view overflows the tab-container width, the added view will be set as active
+         * and rendered at the front of the tab-stack, while the underlying order of tabs will remain unchanged.
+         * If that happens and then getViews() is called, it will return the identities in a different order than
+         * than the currently rendered tab order.
+         *
+         *
+         * @throws If the {@link TabStack} has been destroyed.
+         * @example
+         * ```js
+         * if (!fin.me.isView) {
+         *     throw new Error('Not running in a platform View.');
+         * }
+         *
+         * const stack = await fin.me.getCurrentStack();
+         * // Alternatively, you can wrap any view and get the stack from there
+         * // const viewFromSomewhere = fin.View.wrapSync(someView.identity);
+         * // const stack = await viewFromSomewhere.getCurrentStack();
+         * const views = await stack.getViews();
+         * console.log(`Stack contains ${views.length} view(s)`);
+         * ```
+         * @experimental
+         */
+        this.getViews = () => __classPrivateFieldGet$d(this, _TabStack_client, "f").getStackViews(this.entityId);
+        /**
+         * Adds or creates a view in this {@link TabStack}.
+         *
+         * @remarks Known Issue: If adding a view overflows the tab-container, the added view will be set as active
+         * and rendered at the front of the tab-stack, while the underlying order of tabs will remain unchanged.
+         *
+         * @param view The identity of an existing view to add, or options to create a view.
+         * @param options Optional view options: index number used to insert the view into the stack at that index. Defaults to 0 (front of the stack)
+         * @returns Resolves with the {@link OpenFin.Identity identity} of the added view.
+         * @throws If the view does not exist or fails to create.
+         * @throws If the {@link TabStack} has been destroyed.
+         * @example
+         * ```js
+         * if (!fin.me.isView) {
+         *     throw new Error('Not running in a platform View.');
+         * }
+         *
+         * const stack = await fin.me.getCurrentStack();
+         * // Alternatively, you can wrap any view and get the stack from there
+         * // const viewFromSomewhere = fin.View.wrapSync(someView.identity);
+         * // const stack = await viewFromSomewhere.getCurrentStack();
+         * const googleViewIdentity = await stack.addView({ name: 'google-view', url: 'http://google.com/' });
+         * console.log('Identity of the google view just added', { googleViewIdentity });
+         * // pass in { index: number } to set the index in the stack. Here 1 means, end of the stack (defaults to 0)
+         * const appleViewIdentity = await stack.addView({ name: 'apple-view', url: 'http://apple.com/' }, { index: 1 });
+         * console.log('Identity of the apple view just added', { appleViewIdentity });
+         * ```
+         * @experimental
+         */
+        this.addView = async (view, options = { index: 0 }) => __classPrivateFieldGet$d(this, _TabStack_client, "f").addViewToStack(this.entityId, view, options);
+        /**
+         * Removes a view from this {@link TabStack}.
+         *
+         * @remarks Throws an exception if the view identity does not exist or was already destroyed.
+         *
+         * @param view - Identity of the view to remove.
+         * @throws If the view does not exist or does not belong to the stack.
+         * @throws If the {@link TabStack} has been destroyed.
+         *
+         * @example
+         * ```js
+         * if (!fin.me.isView) {
+         *     throw new Error('Not running in a platform View.');
+         * }
+         *
+         * const stack = await fin.me.getCurrentStack();
+         * const googleViewIdentity = await stack.addView({ name: 'google-view', url: 'http://google.com/' });
+         *
+         * await stack.removeView(googleViewIdentity);
+         *
+         * try {
+         *     await stack.removeView(googleViewIdentity);
+         * } catch (error) {
+         *     // Tried to remove a view ('google-view') which does not belong to the stack.
+         *     console.log(error);
+         * }
+         * ```
+         */
+        this.removeView = async (view) => {
+            await __classPrivateFieldGet$d(this, _TabStack_client, "f").removeViewFromStack(this.entityId, view);
+        };
+        /**
+         * Sets the active view of the {@link TabStack} without focusing it.
+         * @param view - Identity of the view to activate.
+         * @returns Promise which resolves with void once the view has been activated.
+         * @throws If the {@link TabStack} has been destroyed.
+         * @throws If the view does not exist.
+         * @example
+         * Change the active tab of a known View's TabStack:
+         * ```js
+         * const targetView = fin.View.wrapSync({ uuid: 'uuid', name: 'view-name' });
+         * const stack = await targetView.getCurrentStack();
+         * await stack.setActiveView(targetView.identity);
+         * ```
+         *
+         * Set the current View as active within its TabStack:
+         * ```js
+         * const stack = await fin.me.getCurrentStack();
+         * await stack.setActiveView(fin.me.identity);
+         * ```
+         * @experimental
+         */
+        this.setActiveView = async (view) => {
+            await __classPrivateFieldGet$d(this, _TabStack_client, "f").setStackActiveView(this.entityId, view);
+        };
+        __classPrivateFieldSet$b(this, _TabStack_client, client, "f");
+    }
+}
+layoutEntities.TabStack = TabStack;
+_TabStack_client = new WeakMap();
+/**
+ * A ColumnOrRow is used to manage the state of Column and Rows within an OpenFin Layout.
+ */
+class ColumnOrRow extends LayoutNode {
+    /**
+     * @internal
+     */
+    constructor(client, entityId, type) {
+        super(client, entityId);
+        /**
+         * @ignore
+         * @internal
+         * ApiClient for {@link LayoutEntitiesController}
+         */
+        _ColumnOrRow_client.set(this, void 0);
+        /**
+         * Retrieves the content array of the ColumnOrRow
+         *
+         * @example
+         * ```js
+         * if (!fin.me.isView) {
+         *     throw new Error('Not running in a platform View.');
+         * }
+         *
+         * const stack = await fin.me.getCurrentStack();
+         * // Retrieves the parent ColumnOrRow
+         * const columnOrRow = await stack.getParent();
+         *
+         * // returns [TabStack]
+         * const contentArray = await columnOrRow.getContent();
+         * console.log(`The ColumnOrRow has ${contentArray.length} item(s)`);
+         * ```
+         */
+        this.getContent = async () => {
+            const contentItemEntities = await __classPrivateFieldGet$d(this, _ColumnOrRow_client, "f").getContent(this.entityId);
+            return contentItemEntities.map((entity) => LayoutNode.getEntity(entity, __classPrivateFieldGet$d(this, _ColumnOrRow_client, "f")));
+        };
+        __classPrivateFieldSet$b(this, _ColumnOrRow_client, client, "f");
+        this.type = type;
+    }
+}
+layoutEntities.ColumnOrRow = ColumnOrRow;
+_ColumnOrRow_client = new WeakMap();
+
+var layout_constants = {};
+
+Object.defineProperty(layout_constants, "__esModule", { value: true });
+layout_constants.DEFAULT_LAYOUT_KEY = layout_constants.LAYOUT_CONTROLLER_ID = void 0;
+layout_constants.LAYOUT_CONTROLLER_ID = 'layout-entities';
+// TODO: eventually export this somehow
+layout_constants.DEFAULT_LAYOUT_KEY = '__default__';
+
+var main = {};
+
+Object.defineProperty(main, "__esModule", { value: true });
+main.WebContents = void 0;
+const base_1$j = base;
+class WebContents extends base_1$j.EmitterBase {
+    /**
+     * @param identity The identity of the {@link OpenFin.WebContentsEvents WebContents}.
+     * @param entityType The type of the {@link OpenFin.WebContentsEvents WebContents}.
+     */
+    constructor(wire, identity, entityType) {
+        super(wire, entityType, identity.uuid, identity.name);
+        this.identity = identity;
+        this.entityType = entityType;
+    }
+    /**
+     * Gets a base64 encoded image of all or part of the WebContents.
+     * @param options Options for the capturePage call.
+     *
+     * @example
+     *
+     * View:
+     * ```js
+     * const view = fin.View.getCurrentSync();
+     *
+     * // PNG image of a full visible View
+     * console.log(await view.capturePage());
+     *
+     * // Low-quality JPEG image of a defined visible area of the view
+     * const options = {
+     *     area: {
+     *         height: 100,
+     *         width: 100,
+     *         x: 10,
+     *         y: 10,
+     *     },
+     *     format: 'jpg',
+     *     quality: 20
+     * }
+     * console.log(await view.capturePage(options));
+     * ```
+     *
+     * Window:
+     * ```js
+     * const wnd = await fin.Window.getCurrent();
+     *
+     * // PNG image of a full visible window
+     * console.log(await wnd.capturePage());
+     *
+     * // Low-quality JPEG image of a defined visible area of the window
+     * const options = {
+     *     area: {
+     *         height: 100,
+     *         width: 100,
+     *         x: 10,
+     *         y: 10,
+     *     },
+     *     format: 'jpg',
+     *     quality: 20
+     * }
+     * console.log(await wnd.capturePage(options));
+     * ```
+     *
+     * @remarks
+     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
+     * We do not expose an explicit superclass for this functionality, but it does have its own
+     * {@link OpenFin.WebContentsEvents event namespace}.
+     */
+    capturePage(options) {
+        return this.wire.sendAction('capture-page', { options, ...this.identity }).then(({ payload }) => payload.data);
+    }
+    /**
+     * Executes Javascript on the WebContents, restricted to contents you own or contents owned by
+     * applications you have created.
+     * @param code JavaScript code to be executed on the view.
+     *
+     * @example
+     * View:
+     * ```js
+     * async function executeJavaScript(code) {
+     *     const view = await fin.View.wrap({uuid: 'uuid', name: 'view name'});
+     *     return await view.executeJavaScript(code);
+     * }
+     *
+     * executeJavaScript(`console.log('Hello, Openfin')`).then(() => console.log('Javascript excuted')).catch(err => console.log(err));
+     * ```
+     *
+     * Window:
+     * ```js
+     * async function executeJavaScript(code) {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-1',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.executeJavaScript.html',
+     *         autoShow: true
+     *     });
+     *     const win = await app.getWindow();
+     *     return await win.executeJavaScript(code);
+     * }
+     *
+     * executeJavaScript(`console.log('Hello, Openfin')`).then(() => console.log('Javascript excuted')).catch(err => console.log(err));
+     * ```
+     * @remarks
+     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
+     * We do not expose an explicit superclass for this functionality, but it does have its own
+     * {@link OpenFin.WebContentsEvents event namespace}.
+     */
+    executeJavaScript(code) {
+        return this.wire
+            .sendAction('execute-javascript-in-window', { ...this.identity, code })
+            .then(({ payload }) => payload.data);
+    }
+    /**
+     * Returns the zoom level of the WebContents.
+     *
+     * @example
+     * View:
+     * ```js
+     * async function getZoomLevel() {
+     *     const view = await fin.View.getCurrent();
+     *     return await view.getZoomLevel();
+     * }
+     *
+     * getZoomLevel().then(zoomLevel => console.log(zoomLevel)).catch(err => console.log(err));
+     * ```
+     *
+     * Window:
+     * ```js
+     * async function createWin() {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-1',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getZoomLevel.html',
+     *         autoShow: true
+     *     });
+     *     return await app.getWindow();
+     * }
+     *
+     * async function getZoomLevel() {
+     *     const win = await createWin();
+     *     return await win.getZoomLevel();
+     * }
+     *
+     * getZoomLevel().then(zoomLevel => console.log(zoomLevel)).catch(err => console.log(err));
+     * ```
+     * @remarks
+     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
+     * We do not expose an explicit superclass for this functionality, but it does have its own
+     * {@link OpenFin.WebContentsEvents event namespace}.
+     */
+    getZoomLevel() {
+        return this.wire.sendAction('get-zoom-level', this.identity).then(({ payload }) => payload.data);
+    }
+    /**
+     * Sets the zoom level of the WebContents.
+     * @param level The zoom level
+     *
+     * @example
+     * View:
+     * ```js
+     * async function setZoomLevel(number) {
+     *     const view = await fin.View.getCurrent();
+     *     return await view.setZoomLevel(number);
+     * }
+     *
+     * setZoomLevel(4).then(() => console.log('Setting a  zoom level')).catch(err => console.log(err));
+     * ```
+     *
+     * Window:
+     * ```js
+     * async function createWin() {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-1',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.setZoomLevel.html',
+     *         autoShow: true
+     *     });
+     *     return await app.getWindow();
+     * }
+     *
+     * async function setZoomLevel(number) {
+     *     const win = await createWin();
+     *     return await win.setZoomLevel(number);
+     * }
+     *
+     * setZoomLevel(4).then(() => console.log('Setting a  zoom level')).catch(err => console.log(err));
+     * ```
+     * @remarks
+     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
+     * We do not expose an explicit superclass for this functionality, but it does have its own
+     * {@link OpenFin.WebContentsEvents event namespace}.
+     */
+    setZoomLevel(level) {
+        return this.wire.sendAction('set-zoom-level', { ...this.identity, level }).then(() => undefined);
+    }
+    /**
+     * Navigates the WebContents to a specified URL.
+     *
+     * Note: The url must contain the protocol prefix such as http:// or https://.
+     * @param url - The URL to navigate the WebContents to.
+     *
+     * @example
+     * View:
+     * ```js
+     * async function createView() {
+     *     const me = await fin.Window.getCurrent();
+     *     return fin.View.create({
+     *         name: 'viewName',
+     *         target: me.identity,
+     *         bounds: {top: 10, left: 10, width: 200, height: 200}
+     *     });
+     * }
+     *
+     * createView()
+     *     .then(view => view.navigate('https://example.com'))
+     *     .then(() => console.log('navigation complete'))
+     *     .catch(err => console.log(err));
+     * ```
+     *
+     * Window:
+     * ```js
+     * async function navigate() {
+     *     const win = await fin.Window.getCurrent();
+     *     return await win.navigate('https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.navigate.html');
+     * }
+     * navigate().then(() => console.log('Navigate to tutorial')).catch(err => console.log(err));
+     * ```
+     * @experimental
+     * @remarks
+     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
+     * We do not expose an explicit superclass for this functionality, but it does have its own
+     * {@link OpenFin.WebContentsEvents event namespace}.
+     */
+    navigate(url) {
+        return this.wire.sendAction('navigate-window', { ...this.identity, url }).then(() => undefined);
+    }
+    /**
+     * Navigates the WebContents back one page.
+     *
+     * @example
+     * View:
+     * ```js
+     * async function navigateBack() {
+     *     const view = await fin.View.wrap({ name: 'testapp-view', uuid: 'testapp' });
+     *     await view.navigate('https://www.google.com');
+     *     return await view.navigateBack();
+     * }
+     * navigateBack().then(() => console.log('Navigated back')).catch(err => console.log(err));
+     * ```
+     *
+     * Window:
+     * ```js
+     * async function navigateBack() {
+     *     const win = await fin.Window.wrap({ name: 'testapp', uuid: 'testapp' });
+     *     await win.navigate('https://www.google.com');
+     *     return await win.navigateBack();
+     * }
+     * navigateBack().then(() => console.log('Navigated back')).catch(err => console.log(err));
+     * ```
+     * @remarks
+     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
+     * We do not expose an explicit superclass for this functionality, but it does have its own
+     * {@link OpenFin.WebContentsEvents event namespace}.
+     */
+    navigateBack() {
+        return this.wire.sendAction('navigate-window-back', { ...this.identity }).then(() => undefined);
+    }
+    /**
+     * Navigates the WebContents forward one page.
+     *
+     * @example
+     * View:
+     * ```js
+     * async function navigateForward() {
+     *     const view = await fin.View.getCurrent();
+     *     await view.navigate('https://www.google.com');
+     *     await view.navigateBack();
+     *     return await view.navigateForward();
+     * }
+     * navigateForward().then(() => console.log('Navigated forward')).catch(err => console.log(err));
+     * ```
+     *
+     * Window:
+     * ```js
+     * async function navigateForward() {
+     *     const win = await fin.Window.getCurrent();
+     *     await win.navigate('https://www.google.com');
+     *     await win.navigateBack();
+     *     return await win.navigateForward();
+     * }
+     * navigateForward().then(() => console.log('Navigated forward')).catch(err => console.log(err));
+     * ```
+     * @remarks
+     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
+     * We do not expose an explicit superclass for this functionality, but it does have its own
+     * {@link OpenFin.WebContentsEvents event namespace}.
+     */
+    async navigateForward() {
+        await this.wire.sendAction('navigate-window-forward', { ...this.identity });
+    }
+    /**
+     * Stops any current navigation the WebContents is performing.
+     *
+     * @example
+     * View:
+     * ```js
+     * async function stopNavigation() {
+     *     const view = await fin.View.wrap({ name: 'testapp-view', uuid: 'testapp' });
+     *     await view.navigate('https://www.google.com');
+     *     return await view.stopNavigation();
+     * }
+     * stopNavigation().then(() => console.log('you shall not navigate')).catch(err => console.log(err));
+     * ```
+     *
+     * Window:
+     * ```js
+     * async function stopNavigation() {
+     *     const win = await fin.Window.wrap({ name: 'testapp', uuid: 'testapp' });
+     *     await win.navigate('https://www.google.com');
+     *     return await win.stopNavigation();
+     * }
+     * stopNavigation().then(() => console.log('you shall not navigate')).catch(err => console.log(err));
+     * ```
+     * @remarks
+     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
+     * We do not expose an explicit superclass for this functionality, but it does have its own
+     * {@link OpenFin.WebContentsEvents event namespace}.
+     */
+    stopNavigation() {
+        return this.wire.sendAction('stop-window-navigation', { ...this.identity }).then(() => undefined);
+    }
+    /**
+     * Reloads the WebContents
+     *
+     * @example
+     * View:
+     * ```js
+     * async function reload() {
+     * 	const view = await fin.View.getCurrent();
+     *     return await view.reload();
+     * }
+     *
+     * reload().then(() => {
+     * 		console.log('Reloaded view')
+     * }).catch(err => console.log(err));
+     * ```
+     *
+     * Window:
+     * ```js
+     * async function reloadWindow() {
+     * 		const app = await fin.Application.start({
+     * 				name: 'myApp',
+     * 				uuid: 'app-1',
+     * 				url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.reload.html',
+     * 				autoShow: true
+     * 		});
+     * 		const win = await app.getWindow();
+     *     return await win.reload();
+     * }
+     *
+     * reloadWindow().then(() => {
+     * 		console.log('Reloaded window')
+     * }).catch(err => console.log(err));
+     * ```
+     * @remarks
+     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
+     * We do not expose an explicit superclass for this functionality, but it does have its own
+     * {@link OpenFin.WebContentsEvents event namespace}.
+     */
+    reload(ignoreCache = false) {
+        return this.wire
+            .sendAction('reload-window', {
+            ignoreCache,
+            ...this.identity
+        })
+            .then(() => undefined);
+    }
+    /**
+     * Prints the WebContents.
+     * @param options Printer Options
+     *
+     * Note: When `silent` is set to `true`, the API will pick the system's default printer if deviceName
+     * is empty and the default settings for printing.
+     *
+     * Use the CSS style `page-break-before: always;` to force print to a new page.
+     *
+     * @example
+     * ```js
+     * const view = fin.View.getCurrentSync();
+     *
+     * view.print({ silent: false, deviceName: 'system-printer-name' }).then(() => {
+     *     console.log('print call has been sent to the system');
+     * });
+     * ```
+     * @remarks
+     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
+     * We do not expose an explicit superclass for this functionality, but it does have its own
+     * {@link OpenFin.WebContentsEvents event namespace}.
+     */
+    print(options = {}) {
+        return this.wire.sendAction('print', { ...this.identity, options }).then(() => undefined);
+    }
+    /**
+     * Find and highlight text on a page.
+     * @param searchTerm Term to find in page
+     * @param options Search options
+     *
+     * Note: By default, each subsequent call will highlight the next text that matches the search term.
+     *
+     * Returns a promise with the results for the request. By subscribing to the
+     * found-in-page event, you can get the results of this call as well.
+     *
+     * @example
+     * View:
+     * ```js
+     * const view = fin.View.getCurrentSync();
+     *
+     * //By subscribing to the 'found in page' event we can get the results of each findInPage call made.
+     * view.addListener('found-in-page', (event) => {
+     *     console.log(event);
+     * });
+     *
+     * // The promise also returns the results for the request
+     * view.findInPage('a').then((result) => {
+     *     console.log(result)
+     * });
+     * ```
+     *
+     * Window:
+     * ```js
+     * const win = fin.Window.getCurrentSync();
+     *
+     * //By subscribing to the 'found in page' event we can get the results of each findInPage call made.
+     * win.addListener('found-in-page', (event) => {
+     *     console.log(event);
+     * });
+     *
+     * // The promise also returns the results for the request
+     * win.findInPage('a').then((result) => {
+     *     console.log(result)
+     * });
+     * ```
+     * @remarks
+     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
+     * We do not expose an explicit superclass for this functionality, but it does have its own
+     * {@link OpenFin.WebContentsEvents event namespace}.
+     */
+    findInPage(searchTerm, options) {
+        return this.wire
+            .sendAction('find-in-page', { ...this.identity, searchTerm, options })
+            .then(({ payload }) => payload.data);
+    }
+    /**
+     * Stop a {@link View#findInPage findInPage} call by specifying any of these actions:
+     *
+     * * clearSelection - Clear the selection.
+     * * keepSelection - Translate the selection into a normal selection.
+     * * activateSelection - Focus and click the selection node.
+     *
+     * @example
+     * View:
+     * ```js
+     * const view = fin.View.getCurrentSync();
+     *
+     * view.addListener('found-in-page', (event) => {
+     *     setTimeout(() => {
+     *         view.stopFindInPage('clearSelection');
+     *     }, 5000);
+     * });
+     *
+     * view.findInPage('a').then(results => {
+     *     console.log(results);
+     * });
+     * ```
+     *
+     * Window:
+     * ```js
+     * const win = fin.Window.getCurrentSync();
+     *
+     * win.addListener('found-in-page', (event) => {
+     *     setTimeout(() => {
+     *         win.stopFindInPage('clearSelection');
+     *     }, 5000);
+     * });
+     *
+     * win.findInPage('a').then(results => {
+     *     console.log(results);
+     * });
+     * ```
+     * @remarks
+     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
+     * We do not expose an explicit superclass for this functionality, but it does have its own
+     * {@link OpenFin.WebContentsEvents event namespace}.
+     */
+    stopFindInPage(action) {
+        return this.wire.sendAction('stop-find-in-page', { ...this.identity, action }).then(() => undefined);
+    }
+    /**
+     * Returns an array with all system printers
+     * @deprecated use System.getPrinters instead
+     *
+     * @example
+     * View:
+     * ```js
+     * const view = fin.View.getCurrentSync();
+     *
+     * view.getPrinters()
+     *     .then((printers) => {
+     *         printers.forEach((printer) => {
+     *             if (printer.isDefault) {
+     *                 console.log(printer);
+     *             }
+     *         });
+     *     })
+     *     .catch((err) => {
+     *         console.log(err);
+     *     });
+     * ```
+     *
+     * Window:
+     * ```js
+     * const win = fin.Window.getCurrentSync();
+     *
+     * win.getPrinters()
+     *     .then((printers) => {
+     *         printers.forEach((printer) => {
+     *             if (printer.isDefault) {
+     *                 console.log(printer);
+     *             }
+     *         });
+     *     })
+     *     .catch((err) => {
+     *         console.log(err);
+     *     });
+     * ```
+     * @remarks
+     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
+     * We do not expose an explicit superclass for this functionality, but it does have its own
+     * {@link OpenFin.WebContentsEvents event namespace}.
+     */
+    getPrinters() {
+        return this.wire.sendAction('get-printers', { ...this.identity }).then(({ payload }) => payload.data);
+    }
+    /**
+     * Gives focus to the WebContents.
+     *
+     * @example
+     * ```js
+     * async function focusWindow() {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-1',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.focus.html',
+     *         autoShow: true
+     *     });
+     *     const win = await app.getWindow();
+     *     return await win.focus();
+     * }
+     *
+     * focusWindow().then(() => console.log('Window focused')).catch(err => console.log(err));
+     * ```
+     * @remarks
+     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
+     * We do not expose an explicit superclass for this functionality, but it does have its own
+     * {@link OpenFin.WebContentsEvents event namespace}.
+     */
+    async focus({ emitSynthFocused } = { emitSynthFocused: true }) {
+        await this.wire.sendAction('focus-window', { emitSynthFocused, ...this.identity });
+    }
+    /**
+     * Shows the Chromium Developer Tools
+     *
+     * @example
+     * View:
+     * ```js
+     * async function showDeveloperTools() {
+     *     const view = await fin.View.getCurrent();
+     *     return view.showDeveloperTools();
+     * }
+     *
+     * showDevelopertools()
+     * .then(() => console.log('Showing dev tools'))
+     * .catch(err => console.error(err));
+     * ```
+     *
+     * Window:
+     * ```js
+     * async function showDeveloperTools() {
+     *     const win = await fin.Window.getCurrent();
+     *     return win.showDeveloperTools();
+     * }
+     *
+     * showDevelopertools()
+     * .then(() => console.log('Showing dev tools'))
+     * .catch(err => console.error(err));
+     * ```
+     * @remarks
+     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
+     * We do not expose an explicit superclass for this functionality, but it does have its own
+     * {@link OpenFin.WebContentsEvents event namespace}.
+     */
+    async showDeveloperTools() {
+        // Note this hits the system action map in core state for legacy reasons.
+        await this.wire.sendAction('show-developer-tools', this.identity);
+    }
+    /**
+     * Retrieves the process information associated with a WebContents.
+     *
+     * Note: This includes any iframes associated with the WebContents
+     *
+     * @example
+     * View:
+     * ```js
+     *     const view = await fin.View.getCurrent();
+     *     const processInfo = await view.getProcessInfo();
+     * ```
+     *
+     * Window:
+     * ```js
+     *     const win = await fin.Window.getCurrent();
+     *     const processInfo = await win.getProcessInfo();
+     * ```
+     * @remarks
+     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
+     * We do not expose an explicit superclass for this functionality, but it does have its own
+     * {@link OpenFin.WebContentsEvents event namespace}.
+     */
+    async getProcessInfo() {
+        const { payload: { data } } = await this.wire.sendAction('get-process-info', this.identity);
+        return data;
+    }
+    /**
+     * Retrieves information on all Shared Workers.
+     *
+     * @example
+     * View:
+     * ```js
+     *     const view = await fin.View.create({
+     *         name: 'viewName',
+     *         target: fin.me.identity,
+     *         bounds: {top: 10, left: 10, width: 200, height: 200}
+     *     });
+     *
+     *     await view.navigate('https://mdn.github.io/dom-examples/web-workers/simple-shared-worker/');
+     *
+     *     const sharedWorkers = await view.getSharedWorkers();
+     * ```
+     *
+     * Window:
+     * ```js
+     *     const winOption = {
+     *         name:'child',
+     *         defaultWidth: 300,
+     *         defaultHeight: 300,
+     *         url: 'https://mdn.github.io/dom-examples/web-workers/simple-shared-worker/',
+     *         frame: true,
+     *         autoShow: true
+     *     };
+     *     const win = await fin.Window.create(winOption);
+     *     const sharedWorkers = await win.getSharedWorkers();
+     * ```
+     * @remarks
+     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
+     * We do not expose an explicit superclass for this functionality, but it does have its own
+     * {@link OpenFin.WebContentsEvents event namespace}.
+     */
+    async getSharedWorkers() {
+        return this.wire.sendAction('get-shared-workers', this.identity).then(({ payload }) => payload.data);
+    }
+    /**
+     * Opens the developer tools for the shared worker context.
+     *
+     * @example
+     * View:
+     * ```js
+     *     const view = await fin.View.create({
+     *         name: 'viewName',
+     *         target: fin.me.identity,
+     *         bounds: {top: 10, left: 10, width: 200, height: 200}
+     *     });
+     *
+     *     await view.navigate('https://mdn.github.io/dom-examples/web-workers/simple-shared-worker/');
+     *
+     *     await view.inspectSharedWorker();
+     * ```
+     *
+     * Example:
+     * ```js
+     *     const winOption = {
+     *         name:'child',
+     *         defaultWidth: 300,
+     *         defaultHeight: 300,
+     *         url: 'https://mdn.github.io/dom-examples/web-workers/simple-shared-worker/',
+     *         frame: true,
+     *         autoShow: true
+     *     };
+     *     const win = await fin.Window.create(winOption);
+     *     await win.inspectSharedWorker();
+     * ```
+     * @remarks
+     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
+     * We do not expose an explicit superclass for this functionality, but it does have its own
+     * {@link OpenFin.WebContentsEvents event namespace}.
+     */
+    async inspectSharedWorker() {
+        await this.wire.sendAction('inspect-shared-worker', { ...this.identity });
+    }
+    /**
+     * Inspects the shared worker based on its ID.
+     * @param workerId - The id of the shared worker.
+     *
+     * @example
+     * View:
+     * ```js
+     *     const view = await fin.View.create({
+     *         name: 'viewName',
+     *         target: fin.me.identity,
+     *         bounds: {top: 10, left: 10, width: 200, height: 200}
+     *     });
+     *
+     *     await view.navigate('https://mdn.github.io/dom-examples/web-workers/simple-shared-worker/');
+     *
+     *     const sharedWorkers = await view.getSharedWorkers();
+     *     await view.inspectSharedWorkerById(sharedWorkers[0].id);
+     * ```
+     *
+     * Window:
+     * ```js
+     *     const winOption = {
+     *         name:'child',
+     *         defaultWidth: 300,
+     *         defaultHeight: 300,
+     *         url: 'https://mdn.github.io/dom-examples/web-workers/simple-shared-worker/',
+     *         frame: true,
+     *         autoShow: true
+     *     };
+     *     const win = await fin.Window.create(winOption);
+     *     const sharedWorkers = await win.getSharedWorkers();
+     *     await win.inspectSharedWorkerById(sharedWorkers[0].id);
+     * ```
+     * @remarks
+     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
+     * We do not expose an explicit superclass for this functionality, but it does have its own
+     * {@link OpenFin.WebContentsEvents event namespace}.
+     */
+    async inspectSharedWorkerById(workerId) {
+        await this.wire.sendAction('inspect-shared-worker-by-id', { ...this.identity, workerId });
+    }
+    /**
+     * Opens the developer tools for the service worker context.
+     *
+     * @example
+     * View:
+     * ```js
+     *     const view = await fin.View.create({
+     *         name: 'viewName',
+     *         target: fin.me.identity,
+     *         bounds: {top: 10, left: 10, width: 200, height: 200}
+     *     });
+     *
+     *     await view.navigate('http://googlechrome.github.io/samples/service-worker/basic/index.html');
+     *
+     *     await view.inspectServiceWorker();
+     * ```
+     *
+     * Window:
+     * ```js
+     *     const winOption = {
+     *         name:'child',
+     *         defaultWidth: 300,
+     *         defaultHeight: 300,
+     *         url: 'http://googlechrome.github.io/samples/service-worker/basic/index.html',
+     *         frame: true,
+     *         autoShow: true
+     *     };
+     *     const win = await fin.Window.create(winOption);
+     *     await win.inspectServiceWorker();
+     * ```
+     * @remarks
+     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
+     * We do not expose an explicit superclass for this functionality, but it does have its own
+     * {@link OpenFin.WebContentsEvents event namespace}.
+     */
+    async inspectServiceWorker() {
+        await this.wire.sendAction('inspect-service-worker', { ...this.identity });
+    }
+    /**
+     * Shows a popup window.
+     *
+     * Note: If this WebContents is a view and its attached window has a popup open, this will close it.
+     *
+     * Shows a popup window. Including a `name` in `options` will attempt to show an existing window as a popup, if
+     * that window doesn't exist or no `name` is included a window will be created. If the caller view or the caller
+     * view's parent window currently has a popup window open, calling `showPopupWindow` again will dismiss the currently
+     * open popup window before showing the new popup window. Also, if the caller view is destroyed or detached, the popup
+     * will be dismissed.
+     *
+     * Note: in the case where the window being shown as a popup needs to be created, it is a child of the caller view's parent window.
+     *
+     * @example
+     *
+     * Create and show a single-use popup window that returns a single result to the caller. `initialOptions` allows
+     * us to pass window options to the popup window that will be created. `resultDispatchBehavior: 'close'` ensures
+     * that once the popup window calls `dispatchPopupResult` it is closed. `blurBehavior: 'close'` will yield a dismissed
+     * result should the popup window lose focus.
+     *
+     * ```js
+     * const result = await fin.me.showPopupWindow({
+     *     initialOptions: {
+     *         frame: false
+     *     },
+     *     url: '',
+     *     resultDispatchBehavior: 'close',
+     *     blurBehavior: 'close',
+     *     focus: true,
+     *     height: 300,
+     *     width: 300,
+     *     x: 0,
+     *     y: 0
+     * });
+     * ```
+     *
+     * Same as above but using an existing window as a popup by referencing its `name`:
+     *
+     * Note: if a window with the `name` provided doesn't exist, it will be created.
+     *
+     * ```js
+     * const result = await fin.me.showPopupWindow({
+     *     initialOptions: {
+     *         frame: true
+     *     },
+     *     name: 'my-popup', // shows the 'my-popup' window if it exists, otherwise creates it
+     *     url: '', // navigates to this url if it doesn't match the location.href of the 'my-popup' window
+     *     resultDispatchBehavior: 'close',
+     *     blurBehavior: 'close',
+     *     focus: true,
+     *     hideOnClose: true, // persist window on 'dismissed' result, alternatively change onResultDispatch and blurBehavior to 'hide'
+     *     height: 300,
+     *     width: 300,
+     *     x: 0,
+     *     y: 0
+     * });
+     * ```
+     *
+     * Create and show a popup window that is able to return multiple results to the caller via an `onPopupResult` callback. Each
+     * time the popup window calls `dispatchPopupResult`, the callback will be executed on the result. Once the popup window is
+     * closed or hidden, the `showPopupWindow` promise will resolve with a `dismissed` result that will include the most recently
+     * dispatched result as `lastDispatchResult`:
+     *
+     * ```js
+     * const popupResultCallback = (payload) => {
+     *        if (payload.result === 'clicked') {
+     *            if (payload.data.topic === 'color-changed') {
+     *                // do something like
+     *                // setColor(payload.data.value);
+     *            }
+     *        }
+     * };
+     *
+     * await fin.me.showPopupWindow({
+     *     initialOptions: {
+     *         frame: false
+     *     },
+     *     url: '',
+     *     resultDispatchBehavior: 'none',
+     *     blurBehavior: 'close',
+     *     focus: true,
+     *     height: 300,
+     *     width: 300,
+     *     x: 0,
+     *     y: 0,
+     *     onPopupResult: popupResultCallback
+     * });
+     * ```
+     *
+     * Same as above but using an existing window as a popup:
+     *
+     * ```js
+     * const popupResultCallback = (payload) => {
+     *        if (payload.result === 'clicked') {
+     *            if (payload.data.topic === 'color-changed') {
+     *                // do something like
+     *                // setColor(payload.data.value);
+     *            }
+     *        }
+     * };
+     *
+     * await fin.me.showPopupWindow({
+     *     initialOptions: {
+     *         frame: false
+     *     },
+     *     name: 'my-popup', // shows the 'my-popup' window if it exists, otherwise creates it
+     *     url: '', // navigates to this url if it doesn't match the location.href of the 'my-popup' window
+     *     resultDispatchBehavior: 'none',
+     *     blurBehavior: 'hide',
+     *     focus: true,
+     *     hideOnClose: true, // we can just use this or we can change blurBehavior to 'hide'
+     *     height: 300,
+     *     width: 300,
+     *     x: 0,
+     *     y: 0,
+     *     onPopupResult: popupResultCallback
+     * });
+     * ```
+     *
+     * Create or show a popup window that disables user movement (positioning and resizing) in the caller
+     * view's parent window by using `blurBehavior: 'modal'`:
+     *
+     * ```js
+     * const result = await fin.me.showPopupWindow({
+     *     initialOptions: {
+     *         frame: false
+     *     },
+     *     url: '',
+     *     resultDispatchBehavior: 'close',
+     *     blurBehavior: 'modal',
+     *     focus: true,
+     *     height: 300,
+     *     width: 300,
+     *     x: 0,
+     *     y: 0
+     * });
+     * ```
+     *
+     * Create a popup window as a modal:
+     *
+     * Note: The only way to ensure true modal behavior is to create the window being shown as a popup with a
+     * `modalParentIdentity` that uses the caller view's parent window identity.
+     *
+     * ```js
+     * const result = await fin.me.showPopupWindow({
+     *     initialOptions: {
+     *         frame: false,
+     *         modalParentIdentity: fin.me.identity
+     *     },
+     *     url: '',
+     *     resultDispatchBehavior: 'close',
+     *     blurBehavior: 'modal',
+     *     focus: true,
+     *     height: 300,
+     *     width: 300,
+     *     x: 0,
+     *     y: 0
+     * });
+     * ```
+     *
+     * Pass data to a popup window that is available when the popup is shown.
+     *
+     * Note: this is just one example for a use of `additionalOptions`, it can be used to update any updatable
+     * window options when creating or showing an existing window as a popup.
+     *
+     * ```js
+     * const result = await fin.me.showPopupWindow({
+     *     additionalOptions: {
+     *         customData: {
+     *             foo: 'bar'
+     *         }
+     *     },
+     *     url: '',
+     *     resultDispatchBehavior: 'close',
+     *     blurBehavior: 'close',
+     *     focus: true,
+     *     height: 300,
+     *     width: 300,
+     *     x: 0,
+     *     y: 0
+     * });
+     *
+     * // Access from the popup window context like so:
+     * const { customData } = await fin.me.getOptions();
+     * const { foo } = customData;
+     * ```
+     *
+     * Execute a callback on the popup's OpenFin window when the popup is shown:
+     *
+     * ```js
+     * const popupWindowCallback = async (win) => {
+     *     await win.flash();
+     * };
+     *
+     * const result = await fin.me.showPopupWindow({
+     *     url: '',
+     *     resultDispatchBehavior: 'close',
+     *     blurBehavior: 'close',
+     *     focus: true,
+     *     height: 300,
+     *     width: 300,
+     *     x: 0,
+     *     y: 0,
+     *     onPopupReady: popupWindowCallback;
+     * });
+     * ```
+     * @remarks
+     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
+     * We do not expose an explicit superclass for this functionality, but it does have its own
+     * {@link OpenFin.WebContentsEvents event namespace}.
+     */
+    async showPopupWindow(options) {
+        this.wire.sendAction(`${this.entityType}-show-popup-window`, this.identity).catch(() => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        if (options?.onPopupReady) {
+            const readyListener = async ({ popupName }) => {
+                try {
+                    const popupWindow = this.fin.Window.wrapSync({ uuid: this.fin.me.uuid, name: popupName });
+                    await options.onPopupReady(popupWindow);
+                }
+                catch (error) {
+                    throw new Error(`Something went wrong during onPopupReady execution: ${error}`);
+                }
+            };
+            // TODO: fix typing (internal)
+            // @ts-expect-error
+            await this.once('popup-ready', readyListener);
+        }
+        const { payload: tryCreatePayload } = await this.wire.sendAction('try-create-popup-window', {
+            options: {
+                ...options,
+                // Internal use only.
+                // @ts-expect-error
+                hasResultCallback: !!options?.onPopupResult,
+                hasReadyCallback: !!options?.onPopupReady
+            },
+            ...this.identity
+        });
+        const { data: { willOpen, options: popupOptions } } = tryCreatePayload;
+        if (willOpen) {
+            // Solve the issue where Interop in a popup window with non cross-origin url is not working(core-1076).
+            await this.fin.Window.create(popupOptions.initialOptions);
+        }
+        const normalizePopupResult = (payload) => {
+            const { name, uuid, result, data } = payload;
+            const popupResult = {
+                identity: {
+                    name,
+                    uuid
+                },
+                result
+            };
+            if (data) {
+                popupResult.data = data;
+            }
+            return popupResult;
+        };
+        if (options?.onPopupResult) {
+            const dispatchResultListener = async (payload) => {
+                await options.onPopupResult(normalizePopupResult(payload));
+            };
+            const teardownListener = async () => {
+                // TODO: fix typing (internal)
+                // @ts-expect-error
+                await this.removeListener('popup-result', dispatchResultListener);
+            };
+            // TODO: fix typing (internal)
+            // @ts-expect-error
+            await this.on('popup-result', dispatchResultListener);
+            // TODO: fix typing (internal)
+            // hilariously this does not need a ts-expect-error - this is gap in type soundness
+            // should investigate - probably due to `teardownListener` taking a void argument
+            // which might play nicely with the `never` type?  huh...
+            await this.once('popup-teardown', teardownListener);
+        }
+        const { payload } = await this.wire.sendAction('show-popup-window', {
+            options: popupOptions,
+            ...this.identity
+        });
+        return payload.data;
+    }
+}
+main.WebContents = WebContents;
+
+var hasRequiredInstance$2;
+
+function requireInstance$2 () {
+	if (hasRequiredInstance$2) return Instance$5;
+	hasRequiredInstance$2 = 1;
+	var __classPrivateFieldGet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+	    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+	    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+	    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+	};
+	var _View_providerChannelClient;
+	Object.defineProperty(Instance$5, "__esModule", { value: true });
+	Instance$5.View = void 0;
+	const transport_errors_1 = transportErrors;
+	const lazy_1 = lazy;
+	const layout_entities_1 = layoutEntities;
+	const layout_constants_1 = layout_constants;
+	const main_1 = main;
+	const window_1 = requireWindow();
+	/**
+	 * A View can be used to embed additional web content into a Window.
+	 * It is like a child window, except it is positioned relative to its owning window.
+	 * It has the ability to listen for {@link OpenFin.ViewEvents View-specific events}.
+	 *
+	 * By default, a View will try to share the same renderer process as other Views owned by its parent Application.
+	 * To change that behavior, see the processAffinity {@link OpenFin.ViewOptions view option}.
+	 *
+	 * A View's lifecycle is tied to its owning window and can be re-attached to a different window at any point during its lifecycle.
+	 */
+	class View extends main_1.WebContents {
+	    /**
+	     * @internal
+	     */
+	    constructor(wire, identity) {
+	        super(wire, identity, 'view');
+	        this.identity = identity;
+	        _View_providerChannelClient.set(this, new lazy_1.Lazy(() => {
+	            const platform = this.fin.Platform.wrapSync(this.identity);
+	            return platform.getClient();
+	        }));
+	        /**
+	         * Attaches the current view to the given window identity.
+	         * Identity must be the identity of a window in the same application.
+	         * This detaches the view from its current window, and sets the view to be destroyed when its new window closes.
+	         *
+	         * @example
+	         * ```js
+	         * let view;
+	         * async function createView() {
+	         *     const me = await fin.Window.getCurrent();
+	         *     return fin.View.create({
+	         *         name: 'viewNameAttach',
+	         *         target: me.identity,
+	         *         bounds: {top: 10, left: 10, width: 200, height: 200}
+	         *     });
+	         * }
+	         *
+	         * async function attachView() {
+	         *     view = await createView();
+	         *     console.log('View created.');
+	         *
+	         *     await view.navigate('https://google.com');
+	         *     console.log('View navigated to given url.');
+	         *
+	         *     const winOption = {
+	         *         name:'winOptionName',
+	         *         defaultWidth: 300,
+	         *         defaultHeight: 300,
+	         *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.create.html',
+	         *         frame: true,
+	         *         autoShow: true
+	         *     };
+	         *     const newWindow = await fin.Window.create(winOption);
+	         *     view.attach(newWindow.identity);
+	         * }
+	         *
+	         * attachView()
+	         *     .then(() => console.log('View attached to new window.'))
+	         *     .catch(err => console.log(err));
+	         * ```
+	         * @experimental
+	         */
+	        this.attach = async (target) => {
+	            await this.wire.sendAction('attach-view', { target, ...this.identity });
+	        };
+	        /**
+	         * Destroys the current view
+	         *
+	         * @example
+	         * ```js
+	         * const view = fin.View.wrapSync({ uuid: 'viewUuid', name: 'viewName' });
+	         * view.destroy();
+	         * ```
+	         * @experimental
+	         */
+	        this.destroy = async () => {
+	            await this.wire.sendAction('destroy-view', { ...this.identity });
+	        };
+	        /**
+	         * Shows the current view if it is currently hidden.
+	         *
+	         * @example
+	         * ```js
+	         * let view;
+	         * async function createView() {
+	         *     const me = await fin.Window.getCurrent();
+	         *     return fin.View.create({
+	         *         name: 'viewNameShow',
+	         *         target: me.identity,
+	         *         bounds: {top: 10, left: 10, width: 200, height: 200}
+	         *     });
+	         * }
+	         *
+	         * async function hideAndShowView() {
+	         *     view = await createView();
+	         *     console.log('View created.');
+	         *
+	         *     await view.navigate('https://google.com');
+	         *     console.log('View navigated to given url option.');
+	         *
+	         *     await view.hide();
+	         *     console.log("View hidden.");
+	         *
+	         *     view.show();
+	         *     console.log("View shown.");
+	         * }
+	         *
+	         * hideAndShowView()
+	         *     .then(() => console.log('View hidden and shown.'))
+	         *     .catch(err => console.log(err));
+	         * ```
+	         * @experimental
+	         */
+	        this.show = async () => {
+	            await this.wire.sendAction('show-view', { ...this.identity });
+	        };
+	        /**
+	         * Sets the bounds (top, left, width, height) of the view relative to its window and shows it if it is hidden.
+	         * This method ensures the view is both positioned and showing. It will reposition a visible view and both show and reposition a hidden view.
+	         *
+	         * @remarks View position is relative to the bounds of the window.
+	         * ({top: 0, left: 0} represents the top left corner of the window)
+	         *
+	         * @example
+	         * ```js
+	         * let view;
+	         * async function createView() {
+	         *     const me = await fin.Window.getCurrent();
+	         *     return fin.View.create({
+	         *         name: 'viewNameSetBounds',
+	         *         target: me.identity,
+	         *         bounds: {top: 10, left: 10, width: 200, height: 200}
+	         *     });
+	         * }
+	         *
+	         * async function showViewAt() {
+	         *     view = await createView();
+	         *     console.log('View created.');
+	         *
+	         *     await view.navigate('https://google.com');
+	         *     console.log('View navigated to given url.');
+	         *
+	         *     await view.showAt({
+	         *         top: 100,
+	         *         left: 100,
+	         *         width: 300,
+	         *         height: 300
+	         *     }, {
+	         *       bringToFront : true
+	         *     });
+	         * }
+	         *
+	         * showViewAt()
+	         *     .then(() => console.log('View set to new bounds and shown.'))
+	         *     .catch(err => console.log(err));
+	         * ```
+	         * @experimental
+	         */
+	        this.showAt = async (bounds, options = {}) => {
+	            await this.wire.sendAction('show-view-at', { bounds, ...this.identity, options });
+	        };
+	        /**
+	         * Brings the specified view to the front of its current window. This ensures the view will be visible on top of any other views
+	         * which have overlapping bounds with it.
+	         *
+	         * Please note, this is not a permanent action - when a new view is created or attached to the window, it will display on top of all other views
+	         * in the window that share bounds with it.
+	         */
+	        this.bringToFront = async () => {
+	            await this.wire.sendAction('bring-view-to-front', { ...this.identity });
+	        };
+	        /**
+	         * Hides the current view if it is currently visible.
+	         *
+	         * @example
+	         * ```js
+	         * let view;
+	         * async function createView() {
+	         *     const me = await fin.Window.getCurrent();
+	         *     return fin.View.create({
+	         *         name: 'viewNameHide',
+	         *         target: me.identity,
+	         *         bounds: {top: 10, left: 10, width: 200, height: 200}
+	         *     });
+	         * }
+	         *
+	         * async function hideView() {
+	         *     view = await createView();
+	         *     console.log('View created.');
+	         *
+	         *     await view.navigate('https://google.com');
+	         *     console.log('View navigated to given url.');
+	         *
+	         *     await view.hide();
+	         * }
+	         *
+	         * hideView()
+	         *     .then(() => console.log('View hidden.'))
+	         *     .catch(err => console.log(err));
+	         * ```
+	         * @experimental
+	         */
+	        this.hide = async () => {
+	            await this.wire.sendAction('hide-view', { ...this.identity });
+	        };
+	        /**
+	         * Sets the bounds (top, left, width, height) of the view relative to its window.
+	         *
+	         * @remarks View position is relative to the bounds of the window.
+	         * ({top: 0, left: 0} represents the top left corner of the window)
+	         *
+	         * @example
+	         * ```js
+	         * let view;
+	         * async function createView() {
+	         *     const me = await fin.Window.getCurrent();
+	         *     return fin.View.create({
+	         *         name: 'viewNameSetBounds',
+	         *         target: me.identity,
+	         *         bounds: {top: 10, left: 10, width: 200, height: 200}
+	         *     });
+	         * }
+	         *
+	         * async function setViewBounds() {
+	         *     view = await createView();
+	         *     console.log('View created.');
+	         *
+	         *     await view.navigate('https://google.com');
+	         *     console.log('View navigated to given url.');
+	         *
+	         *     await view.setBounds({
+	         *         top: 100,
+	         *         left: 100,
+	         *         width: 300,
+	         *         height: 300
+	         *     });
+	         * }
+	         *
+	         * setViewBounds()
+	         *     .then(() => console.log('View set to new bounds.'))
+	         *     .catch(err => console.log(err));
+	         * ```
+	         * @experimental
+	         */
+	        this.setBounds = async (bounds) => {
+	            await this.wire.sendAction('set-view-bounds', { bounds, ...this.identity });
+	        };
+	        /**
+	         * Gets the bounds (top, left, width, height) of the view relative to its window.
+	         *
+	         * @remarks View position is relative to the bounds of the window.
+	         * ({top: 0, left: 0} represents the top left corner of the window)
+	         *
+	         * @example
+	         * ```js
+	         * const view = await fin.View.create({
+	         *     name: 'viewNameSetBounds',
+	         *     target: fin.me.identity,
+	         *     bounds: {top: 10, left: 10, width: 200, height: 200}
+	         * });
+	         *
+	         * await view.navigate('https://google.com');
+	         *
+	         * await view.setBounds({
+	         *     top: 100,
+	         *     left: 100,
+	         *     width: 300,
+	         *     height: 300
+	         * });
+	         *
+	         * console.log(await view.getBounds());
+	         * ```
+	         * @experimental
+	         */
+	        this.getBounds = async () => {
+	            const ack = await this.wire.sendAction('get-view-bounds', { ...this.identity });
+	            return ack.payload.data;
+	        };
+	        /**
+	         * Gets the View's info.
+	         *
+	         * @example
+	         * ```js
+	         * let view;
+	         * async function createView() {
+	         *     const me = await fin.Window.getCurrent();
+	         *     return fin.View.create({
+	         *         name: 'viewNameGetInfo',
+	         *         target: me.identity,
+	         *         bounds: {top: 10, left: 10, width: 200, height: 200}
+	         *     });
+	         * }
+	         *
+	         * async function getViewInfo() {
+	         *     view = await createView();
+	         *     console.log('View created.');
+	         *
+	         *     await view.navigate('https://google.com');
+	         *     console.log('View navigated to given url.');
+	         *
+	         *     return view.getInfo();
+	         * }
+	         *
+	         * getViewInfo()
+	         *     .then((info) => console.log('View info fetched.', info))
+	         *     .catch(err => console.log(err));
+	         * ```
+	         * @experimental
+	         */
+	        this.getInfo = async () => {
+	            const ack = await this.wire.sendAction('get-view-info', { ...this.identity });
+	            return ack.payload.data;
+	        };
+	        /**
+	         * Retrieves the layout for the window the view is attached to.
+	         *
+	         * @example
+	         * ```js
+	         *     //get the current View
+	         *     const view = await fin.View.getCurrent();
+	         *
+	         *     //get a reference to the Layout for the Window the view is part of
+	         *     const layout = await view.getParentLayout();
+	         * ```
+	         * @experimental
+	         */
+	        this.getParentLayout = async () => {
+	            this.wire.sendAction('view-get-parent-layout', { ...this.identity }).catch(() => {
+	                // don't expose
+	            });
+	            const layoutWindow = await this.getCurrentWindow();
+	            let layoutWindowIdentity = layoutWindow.identity;
+	            // TODO: CORE-1857 - when we tearout active layout or drag a view out of a window, the above identity includes the whole window info.
+	            if (layoutWindowIdentity.identity) {
+	                layoutWindowIdentity = layoutWindowIdentity.identity;
+	            }
+	            try {
+	                const providerChannelClient = await __classPrivateFieldGet(this, _View_providerChannelClient, "f").getValue();
+	                const client = await layout_entities_1.LayoutNode.newLayoutEntitiesClient(providerChannelClient, layout_constants_1.LAYOUT_CONTROLLER_ID, layoutWindowIdentity);
+	                const layoutIdentity = await client.getLayoutIdentityForViewOrThrow(this.identity);
+	                return this.fin.Platform.Layout.wrap(layoutIdentity);
+	            }
+	            catch (e) {
+	                const allowedErrors = [
+	                    'No action registered at target for',
+	                    'getLayoutIdentityForViewOrThrow is not a function'
+	                ];
+	                if (!allowedErrors.some((m) => e.message.includes(m))) {
+	                    throw e;
+	                }
+	                // fallback logic for missing endpoint
+	                return this.fin.Platform.Layout.wrap(layoutWindowIdentity);
+	            }
+	        };
+	        /**
+	         * Gets the View's options.
+	         *
+	         * @example
+	         * ```js
+	         * let view;
+	         * async function createView() {
+	         *     const me = await fin.Window.getCurrent();
+	         *     return fin.View.create({
+	         *         name: 'viewNameGetOptions',
+	         *         target: me.identity,
+	         *         bounds: {top: 10, left: 10, width: 200, height: 200}
+	         *     });
+	         * }
+	         *
+	         * async function getViewOptions() {
+	         *     view = await createView();
+	         *     console.log('View created.');
+	         *
+	         *     await view.navigate('https://google.com');
+	         *     console.log('View navigated to given url.');
+	         *
+	         *     const me = await fin.Window.getCurrent();
+	         *     view = fin.View.wrapSync({ uuid: me.identity.uuid, name: 'viewNameGetOptions' });
+	         *     return view.getOptions();
+	         * }
+	         *
+	         * getViewOptions()
+	         *     .then((info) => console.log('View options fetched.', info))
+	         *     .catch(err => console.log(err));
+	         * ```
+	         * @experimental
+	         */
+	        this.getOptions = async () => {
+	            return this.wire.sendAction('get-view-options', { ...this.identity }).then(({ payload }) => payload.data);
+	        };
+	        /**
+	         * Updates the view's options.
+	         *
+	         * @example
+	         * ```js
+	         * let view;
+	         * async function createView() {
+	         *     const me = await fin.Window.getCurrent();
+	         *     return fin.View.create({
+	         *         url: 'https://google.com',
+	         *         name: 'viewNameUpdateOptions',
+	         *         target: me.identity,
+	         *         bounds: {top: 10, left: 10, width: 200, height: 200}
+	         *     });
+	         * }
+	         *
+	         * async function updateViewOptions() {
+	         *     view = await createView();
+	         *     console.log('View created.');
+	         *
+	         *     await view.navigate('https://google.com');
+	         *     console.log('View navigated to given url option.');
+	         *
+	         *     const newOptions = { autoResize: {
+	         *         width: true,
+	         *         horizontal: true
+	         *     }};
+	         *     return view.updateOptions(newOptions);
+	         * }
+	         *
+	         * updateViewOptions()
+	         *     .then(payload => console.log('View options updated: ', payload))
+	         *     .catch(err => console.log(err));
+	         * ```
+	         * @experimental
+	         */
+	        this.updateOptions = async (options) => {
+	            return this.wire.sendAction('update-view-options', { options, ...this.identity }).then(() => undefined);
+	        };
+	        /**
+	         * Retrieves the window the view is currently attached to.
+	         *
+	         * @example
+	         * ```js
+	         * const view = fin.View.wrapSync({ uuid: 'viewUuid', name: 'viewName' });
+	         * view.getCurrentWindow()
+	         *     .then(win => console.log('current window', win))
+	         *     .catch(err => console.log(err));)
+	         * ```
+	         * @experimental
+	         */
+	        this.getCurrentWindow = async () => {
+	            const { payload: { data } } = await this.wire.sendAction('get-view-window', { ...this.identity });
+	            return new window_1._Window(this.wire, data);
+	        };
+	        /**
+	         * Retrieves the current {@link OpenFin.TabStack} of the view if it belongs to one.
+	         * @returns this view belongs to.
+	         * @throws if this view does not belong to a TabStack or if the window has been destroyed.
+	         * @example
+	         * ```js
+	         * if (!fin.me.isView) {
+	         *     throw new Error('Not running in a platform View.');
+	         * }
+	         *
+	         * const stack = await fin.me.getCurrentStack();
+	         * // Alternatively, you can wrap any view and get the stack from there
+	         * // const viewFromSomewhere = fin.View.wrapSync(someView.identity);
+	         * // const stack = await viewFromSomewhere.getCurrentStack();
+	         * const views = await stack.getViews();
+	         * console.log(`Stack contains ${views.length} view(s)`);
+	         * ```
+	         */
+	        this.getCurrentStack = async () => {
+	            this.wire.sendAction('view-get-current-stack').catch(() => {
+	                // don't expose
+	            });
+	            try {
+	                const layoutWindow = await this.getCurrentWindow();
+	                const providerChannelClient = await __classPrivateFieldGet(this, _View_providerChannelClient, "f").getValue();
+	                const client = await layout_entities_1.LayoutNode.newLayoutEntitiesClient(providerChannelClient, layout_constants_1.LAYOUT_CONTROLLER_ID, layoutWindow.identity);
+	                const stackDefinition = (await client.getStackByView(this.identity));
+	                return layout_entities_1.LayoutNode.getEntity(stackDefinition, client);
+	            }
+	            catch (error) {
+	                throw new transport_errors_1.RuntimeError({ reason: 'This view does not belong to a stack.', error });
+	            }
+	        };
+	        /**
+	         * Triggers the before-unload handler for the View, if one is set.
+	         *
+	         * @remarks Returns `true` if the handler is trying to prevent the View from unloading, and `false` if it isn't.
+	         * Only enabled when setting enableBeforeUnload: true in your View options. If this option is not enabled it will
+	         * always return false.
+	         *
+	         * This method is used internally by the Platform Provider to determine the status of each before unload handler in Views when closing the Window.
+	         *
+	         * @example
+	         *
+	         * ```js
+	         * // from inside a View context
+	         * const unloadPrevented = await fin.me.triggerBeforeUnload();
+	         * ```
+	         *
+	         * @experimental
+	         */
+	        this.triggerBeforeUnload = async () => {
+	            const message = await this.wire.sendAction('trigger-before-unload', { ...this.identity });
+	            return message.payload.data;
+	        };
+	        /**
+	         * **NOTE**: Internal use only.
+	         * Attaches this view to an HTML element in the current context. The view will resize responsively when the element bounds change.
+	         *
+	         * **Known issue**: View.bindToElement does not track position changes, if the element has fixed px width and height values it is possible for the view to not update responsively.
+	         *
+	         * **Known issue**: When View.bindToElement is used on a element that takes up the entire page in a platform window, the bound view will not respond responsively when the window is resized to be smaller.
+	         *
+	         * @param element - HTML element to attach the view to.
+	         * @returns - Cleanup function that will disconnect the element resize observer.
+	         * @internal
+	         * @experimental
+	         * @remarks View will resize accordingly when the element is resized. If the element is repositioned in the DOM the view will not be repositioned, to handle this case call `bindToElement` again once the element changes position.
+	         *
+	         * @example
+	         * ```html
+	         * 

+	         * 
+	         * ```
+	         */
+	        this.bindToElement = async (element) => {
+	            if (!element) {
+	                throw new Error('Element not found.');
+	            }
+	            const onChange = async (bounds) => this.setBounds(bounds);
+	            return this.wire.environment.observeBounds(element, onChange);
+	        };
+	    }
+	    /**
+	     * Focuses the view
+	     *
+	     * @example
+	     * ```js
+	     * const view = fin.View.wrapSync({ uuid: 'viewUuid', name: 'viewName' });
+	     * await view.focus();
+	     * // do things with the focused view
+	     * ```
+	     * @experimental
+	     */
+	    async focus({ emitSynthFocused } = { emitSynthFocused: true }) {
+	        const win = await this.getCurrentWindow();
+	        await win.focusedWebViewWasChanged();
+	        await super.focus({ emitSynthFocused });
+	    }
+	}
+	Instance$5.View = View;
+	_View_providerChannelClient = new WeakMap();
+	return Instance$5;
+}
+
+var hasRequiredView;
+
+function requireView () {
+	if (hasRequiredView) return view;
+	hasRequiredView = 1;
+	(function (exports) {
+		var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    var desc = Object.getOwnPropertyDescriptor(m, k);
+		    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+		      desc = { enumerable: true, get: function() { return m[k]; } };
+		    }
+		    Object.defineProperty(o, k2, desc);
+		}) : (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    o[k2] = m[k];
+		}));
+		var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+		    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+		};
+		Object.defineProperty(exports, "__esModule", { value: true });
+		/**
+		 * Entry points for the OpenFin `View` API (`fin.View`).
+		 *
+		 * * {@link ViewModule} contains static members of the `View` API, accessible through `fin.View`.
+		 * * {@link View} describes an instance of an OpenFin View, e.g. as returned by `fin.View.getCurrent`.
+		 *
+		 * These are separate code entities, and are documented separately.  In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/32.114.76.10/index.html),
+		 * both of these were documented on the same page.
+		 *
+		 * @packageDocumentation
+		 */
+		__exportStar(requireFactory$3(), exports);
+		__exportStar(requireInstance$2(), exports); 
+	} (view));
+	return view;
+}
+
+var hasRequiredInstance$1;
+
+function requireInstance$1 () {
+	if (hasRequiredInstance$1) return Instance$6;
+	hasRequiredInstance$1 = 1;
+	Object.defineProperty(Instance$6, "__esModule", { value: true });
+	Instance$6.Application = void 0;
+	/* eslint-disable import/prefer-default-export */
+	const base_1 = base;
+	const window_1 = requireWindow();
+	const view_1 = requireView();
+	/**
+	 * An object representing an application. Allows the developer to create,
+	 * execute, show/close an application as well as listen to {@link OpenFin.ApplicationEvents application events}.
+	 */
+	class Application extends base_1.EmitterBase {
+	    /**
+	     * @internal
+	     */
+	    constructor(wire, identity) {
+	        super(wire, 'application', identity.uuid);
+	        this.identity = identity;
+	        this.window = new window_1._Window(this.wire, {
+	            uuid: this.identity.uuid,
+	            name: this.identity.uuid
+	        });
+	    }
+	    windowListFromIdentityList(identityList) {
+	        const windowList = [];
+	        identityList.forEach((identity) => {
+	            windowList.push(new window_1._Window(this.wire, {
+	                uuid: identity.uuid,
+	                name: identity.name
+	            }));
+	        });
+	        return windowList;
+	    }
+	    /**
+	     * Determines if the application is currently running.
+	     *
+	     * @example
+	     *
+	     * ```js
+	     * async function isAppRunning() {
+	     *     const app = await fin.Application.getCurrent();
+	     *     return await app.isRunning();
+	     * }
+	     * isAppRunning().then(running => console.log(`Current app is running: ${running}`)).catch(err => console.log(err));
+	     * ```
+	     */
+	    isRunning() {
+	        return this.wire.sendAction('is-application-running', this.identity).then(({ payload }) => payload.data);
+	    }
+	    /**
+	     * Closes the application and any child windows created by the application.
+	     * Cleans the application from state so it is no longer found in getAllApplications.
+	     * @param force Close will be prevented from closing when force is false and
+	     *  ‘close-requested’ has been subscribed to for application’s main window.
+	     *
+	     * @example
+	     *
+	     * ```js
+	     * async function closeApp() {
+	     *     const allApps1 = await fin.System.getAllApplications(); //[{uuid: 'app1', isRunning: true}, {uuid: 'app2', isRunning: true}]
+	     *     const app = await fin.Application.wrap({uuid: 'app2'});
+	     *     await app.quit();
+	     *     const allApps2 = await fin.System.getAllApplications(); //[{uuid: 'app1', isRunning: true}]
+	     *
+	     * }
+	     * closeApp().then(() => console.log('Application quit')).catch(err => console.log(err));
+	     * ```
+	     */
+	    async quit(force = false) {
+	        try {
+	            await this._close(force);
+	            await this.wire.sendAction('destroy-application', { force, ...this.identity });
+	        }
+	        catch (error) {
+	            const acceptableErrors = ['Remote connection has closed', 'Could not locate the requested application'];
+	            if (!acceptableErrors.some((msg) => error.message.includes(msg))) {
+	                throw error;
+	            }
+	        }
+	    }
+	    async _close(force = false) {
+	        try {
+	            await this.wire.sendAction('close-application', { force, ...this.identity });
+	        }
+	        catch (error) {
+	            if (!error.message.includes('Remote connection has closed')) {
+	                throw error;
+	            }
+	        }
+	    }
+	    /**
+	     * @deprecated use Application.quit instead
+	     * Closes the application and any child windows created by the application.
+	     * @param force - Close will be prevented from closing when force is false and ‘close-requested’ has been subscribed to for application’s main window.
+	     * @param callback - called if the method succeeds.
+	     * @param errorCallback - called if the method fails. The reason for failure is passed as an argument.
+	     *
+	     * @example
+	     *
+	     * ```js
+	     * async function closeApp() {
+	     *     const app = await fin.Application.getCurrent();
+	     *     return await app.close();
+	     * }
+	     * closeApp().then(() => console.log('Application closed')).catch(err => console.log(err));
+	     * ```
+	     */
+	    close(force = false) {
+	        console.warn('Deprecation Warning: Application.close is deprecated Please use Application.quit');
+	        this.wire.sendAction('application-close', this.identity).catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        return this._close(force);
+	    }
+	    /**
+	     * Retrieves an array of wrapped fin.Windows for each of the application’s child windows.
+	     *
+	     * @example
+	     *
+	     * ```js
+	     * async function getChildWindows() {
+	     *     const app = await fin.Application.getCurrent();
+	     *     return await app.getChildWindows();
+	     * }
+	     *
+	     * getChildWindows().then(children => console.log(children)).catch(err => console.log(err));
+	     * ```
+	     */
+	    getChildWindows() {
+	        return this.wire.sendAction('get-child-windows', this.identity).then(({ payload }) => {
+	            const identityList = [];
+	            payload.data.forEach((winName) => {
+	                identityList.push({ uuid: this.identity.uuid, name: winName });
+	            });
+	            return this.windowListFromIdentityList(identityList);
+	        });
+	    }
+	    /**
+	     * Retrieves the JSON manifest that was used to create the application. Invokes the error callback
+	     * if the application was not created from a manifest.
+	     *
+	     * @example
+	     *
+	     * ```js
+	     * async function getManifest() {
+	     *     const app = await fin.Application.getCurrent();
+	     *     return await app.getManifest();
+	     * }
+	     *
+	     * getManifest().then(manifest => console.log(manifest)).catch(err => console.log(err));
+	     * ```
+	     */
+	    getManifest() {
+	        return this.wire.sendAction('get-application-manifest', this.identity).then(({ payload }) => payload.data);
+	    }
+	    /**
+	     * Retrieves UUID of the application that launches this application. Invokes the error callback
+	     * if the application was created from a manifest.
+	     *
+	     * @example
+	     *
+	     * ```js
+	     * async function getParentUuid() {
+	     *     const app = await fin.Application.start({
+	     *         uuid: 'app-1',
+	     *         name: 'myApp',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Application.getParentUuid.html',
+	     *         autoShow: true
+	     *     });
+	     *     return await app.getParentUuid();
+	     * }
+	     *
+	     * getParentUuid().then(parentUuid => console.log(parentUuid)).catch(err => console.log(err));
+	     * ```
+	     */
+	    getParentUuid() {
+	        return this.wire.sendAction('get-parent-application', this.identity).then(({ payload }) => payload.data);
+	    }
+	    /**
+	     * Retrieves current application's shortcut configuration.
+	     *
+	     * @example
+	     *
+	     * ```js
+	     * async function getShortcuts() {
+	     *     const app = await fin.Application.wrap({ uuid: 'testapp' });
+	     *     return await app.getShortcuts();
+	     * }
+	     * getShortcuts().then(config => console.log(config)).catch(err => console.log(err));
+	     * ```
+	     */
+	    getShortcuts() {
+	        return this.wire.sendAction('get-shortcuts', this.identity).then(({ payload }) => payload.data);
+	    }
+	    /**
+	     * Retrieves current application's views.
+	     * @experimental
+	     *
+	     * @example
+	     *
+	     * ```js
+	     * async function getViews() {
+	     *     const app = await fin.Application.getCurrent();
+	     *     return await app.getViews();
+	     * }
+	     * getViews().then(views => console.log(views)).catch(err => console.log(err));
+	     * ```
+	     */
+	    async getViews() {
+	        const { payload } = await this.wire.sendAction('application-get-views', this.identity);
+	        return payload.data.map((id) => new view_1.View(this.wire, id));
+	    }
+	    /**
+	     * Returns the current zoom level of the application.
+	     *
+	     * @example
+	     *
+	     * ```js
+	     * async function getZoomLevel() {
+	     *     const app = await fin.Application.getCurrent();
+	     *     return await app.getZoomLevel();
+	     * }
+	     *
+	     * getZoomLevel().then(zoomLevel => console.log(zoomLevel)).catch(err => console.log(err));
+	     * ```
+	     */
+	    getZoomLevel() {
+	        return this.wire.sendAction('get-application-zoom-level', this.identity).then(({ payload }) => payload.data);
+	    }
+	    /**
+	     * Returns an instance of the main Window of the application
+	     *
+	     * @example
+	     *
+	     * ```js
+	     * async function getWindow() {
+	     *     const app = await fin.Application.start({
+	     *         uuid: 'app-1',
+	     *         name: 'myApp',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Application.getWindow.html',
+	     *         autoShow: true
+	     *     });
+	     *     return await app.getWindow();
+	     * }
+	     *
+	     * getWindow().then(win => {
+	     *     win.showAt(0, 400);
+	     *     win.flash();
+	     * }).catch(err => console.log(err));
+	     * ```
+	     */
+	    getWindow() {
+	        this.wire.sendAction('application-get-window', this.identity).catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        return Promise.resolve(this.window);
+	    }
+	    /**
+	     * Manually registers a user with the licensing service. The only data sent by this call is userName and appName.
+	     * @param userName - username to be passed to the RVM.
+	     * @param appName - app name to be passed to the RVM.
+	     *
+	     * @example
+	     *
+	     * ```js
+	     * async function registerUser() {
+	     *     const app = await fin.Application.getCurrent();
+	     *     return await app.registerUser('user', 'myApp');
+	     * }
+	     *
+	     * registerUser().then(() => console.log('Successfully registered the user')).catch(err => console.log(err));
+	     * ```
+	     */
+	    registerUser(userName, appName) {
+	        return this.wire.sendAction('register-user', { userName, appName, ...this.identity }).then(() => undefined);
+	    }
+	    /**
+	     * Removes the application’s icon from the tray.
+	     *
+	     * @example
+	     *
+	     * ```js
+	     * async function removeTrayIcon() {
+	     *     const app = await fin.Application.getCurrent();
+	     *     return await app.removeTrayIcon();
+	     * }
+	     *
+	     * removeTrayIcon().then(() => console.log('Removed the tray icon.')).catch(err => console.log(err));
+	     * ```
+	     */
+	    removeTrayIcon() {
+	        return this.wire.sendAction('remove-tray-icon', this.identity).then(() => undefined);
+	    }
+	    /**
+	     * Restarts the application.
+	     *
+	     * @example
+	     *
+	     * ```js
+	     * async function restartApp() {
+	     *     const app = await fin.Application.getCurrent();
+	     *     return await app.restart();
+	     * }
+	     * restartApp().then(() => console.log('Application restarted')).catch(err => console.log(err));
+	     * ```
+	     */
+	    restart() {
+	        return this.wire.sendAction('restart-application', this.identity).then(() => undefined);
+	    }
+	    /**
+	     * DEPRECATED method to run the application.
+	     * Needed when starting application via {@link Application.create}, but NOT needed when starting via {@link Application.start}.
+	     *
+	     * @example
+	     *
+	     * ```js
+	     * async function run() {
+	     *     const app = await fin.Application.create({
+	     *         name: 'myApp',
+	     *         uuid: 'app-1',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Application.run.html',
+	     *         autoShow: true
+	     *     });
+	     *     await app.run();
+	     * }
+	     * run().then(() => console.log('Application is running')).catch(err => console.log(err));
+	     * ```
+	     *
+	     * @ignore
+	     */
+	    run() {
+	        console.warn('Deprecation Warning: Application.run is deprecated Please use fin.Application.start');
+	        this.wire.sendAction('application-run', this.identity).catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        return this._run();
+	    }
+	    _run(opts = {}) {
+	        return this.wire
+	            .sendAction('run-application', {
+	            manifestUrl: this._manifestUrl,
+	            opts,
+	            ...this.identity
+	        })
+	            .then(() => undefined);
+	    }
+	    /**
+	     * Instructs the RVM to schedule one restart of the application.
+	     *
+	     * @example
+	     *
+	     * ```js
+	     * async function scheduleRestart() {
+	     *     const app = await fin.Application.getCurrent();
+	     *     return await app.scheduleRestart();
+	     * }
+	     *
+	     * scheduleRestart().then(() => console.log('Application is scheduled to restart')).catch(err => console.log(err));
+	     * ```
+	     */
+	    scheduleRestart() {
+	        return this.wire.sendAction('relaunch-on-close', this.identity).then(() => undefined);
+	    }
+	    /**
+	     * Sends a message to the RVM to upload the application's logs. On success,
+	     * an object containing logId is returned.
+	     *
+	     * @example
+	     *
+	     * ```js
+	     * async function sendLog() {
+	     *     const app = await fin.Application.getCurrent();
+	     *     return await app.sendApplicationLog();
+	     * }
+	     *
+	     * sendLog().then(info => console.log(info.logId)).catch(err => console.log(err));
+	     * ```
+	     */
+	    async sendApplicationLog() {
+	        const { payload } = await this.wire.sendAction('send-application-log', this.identity);
+	        return payload.data;
+	    }
+	    /**
+	     * Sets or removes a custom JumpList for the application. Only applicable in Windows OS.
+	     * If categories is null the previously set custom JumpList (if any) will be replaced by the standard JumpList for the app (managed by Windows).
+	     *
+	     * Note: If the "name" property is omitted it defaults to "tasks".
+	     * @param jumpListCategories An array of JumpList Categories to populate. If null, remove any existing JumpList configuration and set to Windows default.
+	     *
+	     *
+	     * @remarks If categories is null the previously set custom JumpList (if any) will be replaced by the standard JumpList for the app (managed by Windows).
+	     *
+	     * The bottommost item in the jumplist will always be an item pointing to the current app. Its name is taken from the manifest's
+	     * **` shortcut.name `** and uses **` shortcut.company `** as a fallback. Clicking that item will launch the app from its current manifest.
+	     *
+	     * Note: If the "name" property is omitted it defaults to "tasks".
+	     *
+	     * Note: Window OS caches jumplists icons, therefore an icon change might only be visible after the cache is removed or the
+	     * uuid or shortcut.name is changed.
+	     *
+	     * @example
+	     *
+	     * ```js
+	     *     const app = fin.Application.getCurrentSync();
+	     *     const appName = 'My App';
+	     *     const jumpListConfig = [ // array of JumpList categories
+	     *         {
+	     *             // has no name and no type so `type` is assumed to be "tasks"
+	     *             items: [ // array of JumpList items
+	     *             {
+	     *                 type: 'task',
+	     *                 title: `Launch ${appName}`,
+	     *                 description: `Runs ${appName} with the default configuration`,
+	     *                 deepLink: 'fins://path.to/app/manifest.json',
+	     *                 iconPath: 'https://path.to/app/icon.ico',
+	     *                 iconIndex: 0
+	     *             },
+	     *             { type: 'separator' },
+	     *             {
+	     *                 type: 'task',
+	     *                 title: `Restore ${appName}`,
+	     *                 description: 'Restore to last configuration',
+	     *                 deepLink: 'fins://path.to/app/manifest.json?$$use-last-configuration=true',
+	     *                 iconPath: 'https://path.to/app/icon.ico',
+	     *                 iconIndex: 0
+	     *             },
+	     *             ]
+	     *         },
+	     *         {
+	     *             name: 'Tools',
+	     *             items: [ // array of JumpList items
+	     *             {
+	     *                 type: 'task',
+	     *                 title: 'Tool A',
+	     *                 description: 'Runs Tool A',
+	     *                 deepLink: 'fins://path.to/tool-a/manifest.json',
+	     *                 iconPath: 'https://path.to/tool-a/icon.ico',
+	     *                 iconIndex: 0
+	     *             },
+	     *             {
+	     *                 type: 'task',
+	     *                 title: 'Tool B',
+	     *                 description: 'Runs Tool B',
+	     *                 deepLink: 'fins://path.to/tool-b/manifest.json',
+	     *                 iconPath: 'https://path.to/tool-b/icon.ico',
+	     *                 iconIndex: 0
+	     *             }]
+	     *         }
+	     *     ];
+	     *
+	     *     app.setJumpList(jumpListConfig).then(() => console.log('JumpList applied')).catch(e => console.log(`JumpList failed to apply: ${e.toString()}`));
+	     * ```
+	     *
+	     * To handle deeplink args:
+	     * ```js
+	     *     function handleUseLastConfiguration() {
+	     *         // this handler is called when the app is being launched
+	     *         app.on('run-requested', event => {
+	     *             if(event.userAppConfigArgs['use-last-configuration']) {
+	     *                 // your logic here
+	     *             }
+	     *         });
+	     *         // this handler is called when the app was already running when the launch was requested
+	     *         fin.desktop.main(function(args) {
+	     *             if(args && args['use-last-configuration']) {
+	     *                 // your logic here
+	     *             }
+	     *         });
+	     *     }
+	     * ```
+	     */
+	    async setJumpList(jumpListCategories) {
+	        await this.wire.sendAction('set-jump-list', { config: jumpListCategories, ...this.identity });
+	    }
+	    /**
+	     * Adds a customizable icon in the system tray.  To listen for a click on the icon use the `tray-icon-clicked` event.
+	     * @param icon Image URL or base64 encoded string to be used as the icon
+	     *
+	     * @example
+	     *
+	     * ```js
+	     * const imageUrl = "http://cdn.openfin.co/assets/testing/icons/circled-digit-one.png";
+	     * const base64EncodedImage = "iVBORw0KGgoAAAANSUhEUgAAAAgAAAAIAQMAAAD+wSzIAAAABlBMVEX\
+	     * ///+/v7+jQ3Y5AAAADklEQVQI12P4AIX8EAgALgAD/aNpbtEAAAAASUVORK5CYII";
+	     * const dataURL = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DH\
+	     * xgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg==";
+	     *
+	     * async function setTrayIcon(icon) {
+	     *     const app = await fin.Application.getCurrent();
+	     *     return await app.setTrayIcon(icon);
+	     * }
+	     *
+	     * // use image url to set tray icon
+	     * setTrayIcon(imageUrl).then(() => console.log('Setting tray icon')).catch(err => console.log(err));
+	     *
+	     * // use base64 encoded string to set tray icon
+	     * setTrayIcon(base64EncodedImage).then(() => console.log('Setting tray icon')).catch(err => console.log(err));
+	     *
+	     * // use a dataURL to set tray icon
+	     * setTrayIcon(dataURL).then(() => console.log('Setting tray icon')).catch(err => console.log(err));
+	     * ```
+	     */
+	    setTrayIcon(icon) {
+	        return this.wire
+	            .sendAction('set-tray-icon', {
+	            enabledIcon: icon,
+	            ...this.identity
+	        })
+	            .then(() => undefined);
+	    }
+	    /**
+	     * Sets new application's shortcut configuration. Windows only.
+	     * @param config New application's shortcut configuration.
+	     *
+	     * @remarks Application has to be launched with a manifest and has to have shortcut configuration (icon url, name, etc.) in its manifest
+	     * to be able to change shortcut states.
+	     *
+	     * @example
+	     *
+	     * ```js
+	     * async function setShortcuts(config) {
+	     *     const app = await fin.Application.getCurrent();
+	     *     return app.setShortcuts(config);
+	     * }
+	     *
+	     * setShortcuts({
+	     *     desktop: true,
+	     *     startMenu: false,
+	     *     systemStartup: true
+	     * }).then(() => console.log('Shortcuts are set.')).catch(err => console.log(err));
+	     * ```
+	     */
+	    setShortcuts(config) {
+	        return this.wire.sendAction('set-shortcuts', { data: config, ...this.identity }).then(() => undefined);
+	    }
+	    /**
+	     * Sets the query string in all shortcuts for this app. Requires RVM 5.5+.
+	     * @param queryString The new query string for this app's shortcuts.
+	     *
+	     * @example
+	     *
+	     * ```js
+	     * const newQueryArgs = 'arg=true&arg2=false';
+	     * const app = await fin.Application.getCurrent();
+	     * try {
+	     *     await app.setShortcutQueryParams(newQueryArgs);
+	     * } catch(err) {
+	     *     console.error(err)
+	     * }
+	     * ```
+	     */
+	    async setShortcutQueryParams(queryString) {
+	        await this.wire.sendAction('set-shortcut-query-args', { data: queryString, ...this.identity });
+	    }
+	    /**
+	     * Sets the zoom level of the application. The original size is 0 and each increment above or below represents zooming 20%
+	     * larger or smaller to default limits of 300% and 50% of original size, respectively.
+	     * @param level The zoom level
+	     *
+	     * @example
+	     *
+	     * ```js
+	     * async function setZoomLevel(number) {
+	     *     const app = await fin.Application.getCurrent();
+	     *     return await app.setZoomLevel(number);
+	     * }
+	     *
+	     * setZoomLevel(5).then(() => console.log('Setting a  zoom level')).catch(err => console.log(err));
+	     * ```
+	     */
+	    setZoomLevel(level) {
+	        return this.wire.sendAction('set-application-zoom-level', { level, ...this.identity }).then(() => undefined);
+	    }
+	    /**
+	     * Sets a username to correlate with App Log Management.
+	     * @param username Username to correlate with App's Log.
+	     *
+	     * @example
+	     *
+	     * ```js
+	     * async function setAppLogUser() {
+	     *     const app = await fin.Application.getCurrent();
+	     *     return await app.setAppLogUsername('username');
+	     * }
+	     *
+	     * setAppLogUser().then(() => console.log('Success')).catch(err => console.log(err));
+	     *
+	     * ```
+	     */
+	    async setAppLogUsername(username) {
+	        await this.wire.sendAction('set-app-log-username', { data: username, ...this.identity });
+	    }
+	    /**
+	     * Retrieves information about the system tray. If the system tray is not set, it will throw an error message.
+	     * @remarks The only information currently returned is the position and dimensions.
+	     *
+	     * @example
+	     *
+	     * ```js
+	     * async function getTrayIconInfo() {
+	     *     const app = await fin.Application.wrap({ uuid: 'testapp' });
+	     *     return await app.getTrayIconInfo();
+	     * }
+	     * getTrayIconInfo().then(info => console.log(info)).catch(err => console.log(err));
+	     * ```
+	     */
+	    getTrayIconInfo() {
+	        return this.wire.sendAction('get-tray-icon-info', this.identity).then(({ payload }) => payload.data);
+	    }
+	    /**
+	     * Checks if the application has an associated tray icon.
+	     *
+	     * @example
+	     *
+	     * ```js
+	     * const app = await fin.Application.wrap({ uuid: 'testapp' });
+	     * const hasTrayIcon = await app.hasTrayIcon();
+	     * console.log(hasTrayIcon);
+	     * ```
+	     */
+	    hasTrayIcon() {
+	        return this.wire.sendAction('has-tray-icon', this.identity).then(({ payload }) => payload.data);
+	    }
+	    /**
+	     * Closes the application by terminating its process.
+	     *
+	     * @example
+	     *
+	     * ```js
+	     * async function terminateApp() {
+	     *     const app = await fin.Application.getCurrent();
+	     *     return await app.terminate();
+	     * }
+	     * terminateApp().then(() => console.log('Application terminated')).catch(err => console.log(err));
+	     * ```
+	     */
+	    terminate() {
+	        return this.wire.sendAction('terminate-application', this.identity).then(() => undefined);
+	    }
+	    /**
+	     * Waits for a hanging application. This method can be called in response to an application
+	     * "not-responding" to allow the application to continue and to generate another "not-responding"
+	     * message after a certain period of time.
+	     *
+	     * @ignore
+	     */
+	    wait() {
+	        return this.wire.sendAction('wait-for-hung-application', this.identity).then(() => undefined);
+	    }
+	    /**
+	     * Retrieves information about the application.
+	     *
+	     * @remarks If the application was not launched from a manifest, the call will return the closest parent application `manifest`
+	     * and `manifestUrl`.  `initialOptions` shows the parameters used when launched programmatically, or the `startup_app` options
+	     * if launched from manifest. The `parentUuid` will be the uuid of the immediate parent (if applicable).
+	     *
+	     * @example
+	     *
+	     * ```js
+	     * async function getInfo() {
+	     *     const app = await fin.Application.getCurrent();
+	     *     return await app.getInfo();
+	     * }
+	     *
+	     * getInfo().then(info => console.log(info)).catch(err => console.log(err));
+	     * ```
+	     */
+	    getInfo() {
+	        return this.wire.sendAction('get-info', this.identity).then(({ payload }) => payload.data);
+	    }
+	    /**
+	     * Retrieves all process information for entities (windows and views) associated with an application.
+	     *
+	     * @example
+	     * ```js
+	     *     const app = await fin.Application.getCurrent();
+	     *     const processInfo = await app.getProcessInfo();
+	     * ```
+	     * @experimental
+	     */
+	    async getProcessInfo() {
+	        const { payload: { data } } = await this.wire.sendAction('application-get-process-info', this.identity);
+	        return data;
+	    }
+	    /**
+	     * Sets file auto download location. It's only allowed in the same application.
+	     *
+	     * Note: This method is restricted by default and must be enabled via
+	     * API security settings.
+	     * @param downloadLocation file auto download location
+	     *
+	     * @throws if setting file auto download location on different applications.
+	     * @example
+	     *
+	     * ```js
+	     * const downloadLocation = 'C:\\dev\\temp';
+	     * const app = await fin.Application.getCurrent();
+	     * try {
+	     *     await app.setFileDownloadLocation(downloadLocation);
+	     *     console.log('File download location is set');
+	     * } catch(err) {
+	     *     console.error(err)
+	     * }
+	     * ```
+	     */
+	    async setFileDownloadLocation(downloadLocation) {
+	        const { name } = this.wire.me;
+	        const entityIdentity = { uuid: this.identity.uuid, name };
+	        await this.wire.sendAction('set-file-download-location', { ...entityIdentity, downloadLocation });
+	    }
+	    /**
+	     * Gets file auto download location. It's only allowed in the same application. If file auto download location is not set, it will return the default location.
+	     *
+	     * Note: This method is restricted by default and must be enabled via
+	     * API security settings.
+	     *
+	     * @throws if getting file auto download location on different applications.
+	     * @example
+	     *
+	     * ```js
+	     * const app = await fin.Application.getCurrent();
+	     * const fileDownloadDir =  await app.getFileDownloadLocation();
+	     * ```
+	     */
+	    async getFileDownloadLocation() {
+	        const { payload: { data } } = await this.wire.sendAction('get-file-download-location', this.identity);
+	        return data;
+	    }
+	    /**
+	     * Shows a menu on the tray icon. Use with tray-icon-clicked event.
+	     * @param options
+	     * @typeParam Data User-defined shape for data returned upon menu item click. Should be a
+	     * [union](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#union-types)
+	     * of all possible data shapes for the entire menu, and the click handler should process
+	     * these with a "reducer" pattern.
+	     * @throws if the application has no tray icon set
+	     * @throws if the system tray is currently hidden
+	     * @example
+	     *
+	     * ```js
+	     * const iconUrl = 'http://cdn.openfin.co/assets/testing/icons/circled-digit-one.png';
+	     * const app = fin.Application.getCurrentSync();
+	     *
+	     * await app.setTrayIcon(iconUrl);
+	     *
+	     * const template = [
+	     *  {
+	     *    label: 'Menu Item 1',
+	     *    data: 'hello from item 1'
+	     *  },
+	     *  { type: 'separator' },
+	     *  {
+	     *    label: 'Menu Item 2',
+	     *    type: 'checkbox',
+	     *    checked: true,
+	     *    data: 'The user clicked the checkbox'
+	     *  },
+	     *  {
+	     *    label: 'see more',
+	     *    enabled: false,
+	     *    submenu: [
+	     *      { label: 'submenu 1', data: 'hello from submenu' }
+	     *    ]
+	     *  }
+	     * ];
+	     *
+	     * app.addListener('tray-icon-clicked', (event) => {
+	     *   // right-click
+	     *   if (event.button === 2) {
+	     *     app.showTrayIconPopupMenu({ template }).then(r => {
+	     *       if (r.result === 'closed') {
+	     *         console.log('nothing happened');
+	     *       } else {
+	     *         console.log(r.data);
+	     *       }
+	     *     });
+	     *   }
+	     * });
+	     * ```
+	     */
+	    async showTrayIconPopupMenu(options) {
+	        const { name } = this.wire.me;
+	        const entityIdentity = { uuid: this.identity.uuid, name };
+	        const { payload } = await this.wire.sendAction('show-tray-icon-popup-menu', { ...entityIdentity, options });
+	        return payload.data;
+	    }
+	    /**
+	     * Closes the tray icon menu.
+	     *
+	     * @throws if the application has no tray icon set
+	     * @example
+	     *
+	     * ```js
+	     * const app = fin.Application.getCurrentSync();
+	     *
+	     * await app.closeTrayIconPopupMenu();
+	     * ```
+	     */
+	    async closeTrayIconPopupMenu() {
+	        const { name } = this.wire.me;
+	        const entityIdentity = { uuid: this.identity.uuid, name };
+	        await this.wire.sendAction('close-tray-icon-popup-menu', { ...entityIdentity });
+	    }
+	}
+	Instance$6.Application = Application;
+	return Instance$6;
+}
+
+var hasRequiredFactory$2;
+
+function requireFactory$2 () {
+	if (hasRequiredFactory$2) return Factory$7;
+	hasRequiredFactory$2 = 1;
+	Object.defineProperty(Factory$7, "__esModule", { value: true });
+	Factory$7.ApplicationModule = void 0;
+	const base_1 = base;
+	const validate_1 = validate;
+	const Instance_1 = requireInstance$1();
+	/**
+	 * Static namespace for OpenFin API methods that interact with the {@link Application} class, available under `fin.Application`.
+	 */
+	class ApplicationModule extends base_1.Base {
+	    /**
+	     * Asynchronously returns an API handle for the given Application identity.
+	     *
+	     * @remarks Wrapping an Application identity that does not yet exist will *not* throw an error, and instead
+	     * returns a stub object that cannot yet perform rendering tasks. This can be useful for plumbing eventing
+	     * for an Application throughout its entire lifecycle.
+	     *
+	     * @example
+	     *
+	     * ```js
+	     * fin.Application.wrap({ uuid: 'testapp' })
+	     * .then(app => app.isRunning())
+	     * .then(running => console.log('Application is running: ' + running))
+	     * .catch(err => console.log(err));
+	     * ```
+	     *
+	     */
+	    async wrap(identity) {
+	        this.wire.sendAction('wrap-application').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        const errorMsg = (0, validate_1.validateIdentity)(identity);
+	        if (errorMsg) {
+	            throw new Error(errorMsg);
+	        }
+	        return new Instance_1.Application(this.wire, identity);
+	    }
+	    /**
+	     * Synchronously returns an API handle for the given Application identity.
+	     *
+	     * @remarks Wrapping an Application identity that does not yet exist will *not* throw an error, and instead
+	     * returns a stub object that cannot yet perform rendering tasks. This can be useful for plumbing eventing
+	     * for an Aplication throughout its entire lifecycle.
+	     *
+	     * @example
+	     *
+	     * ```js
+	     * const app = fin.Application.wrapSync({ uuid: 'testapp' });
+	     * await app.close();
+	     * ```
+	     *
+	     */
+	    wrapSync(identity) {
+	        this.wire.sendAction('wrap-application-sync').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        const errorMsg = (0, validate_1.validateIdentity)(identity);
+	        if (errorMsg) {
+	            throw new Error(errorMsg);
+	        }
+	        return new Instance_1.Application(this.wire, identity);
+	    }
+	    async _create(appOptions) {
+	        // set defaults:
+	        if (appOptions.waitForPageLoad === undefined) {
+	            appOptions.waitForPageLoad = false;
+	        }
+	        if (appOptions.autoShow === undefined && appOptions.isPlatformController === undefined) {
+	            appOptions.autoShow = true;
+	        }
+	        await this.wire.sendAction('create-application', appOptions);
+	        return this.wrap({ uuid: appOptions.uuid });
+	    }
+	    /**
+	     * DEPRECATED method to create a new Application. Use {@link Application.ApplicationModule.start Application.start} instead.
+	     *
+	     * @example
+	     *
+	     * ```js
+	     * async function createApp() {
+	     *     const app = await fin.Application.create({
+	     *         name: 'myApp',
+	     *         uuid: 'app-3',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Application.create.html',
+	     *         autoShow: true
+	     *     });
+	     *     await app.run();
+	     * }
+	     *
+	     * createApp().then(() => console.log('Application is created')).catch(err => console.log(err));
+	     * ```
+	     *
+	     * @ignore
+	     */
+	    create(appOptions) {
+	        console.warn('Deprecation Warning: fin.Application.create is deprecated. Please use fin.Application.start');
+	        this.wire.sendAction('application-create').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        return this._create(appOptions);
+	    }
+	    /**
+	     * Creates and starts a new Application.
+	     *
+	     * @example
+	     *
+	     * ```js
+	     * async function start() {
+	     *     return fin.Application.start({
+	     *         name: 'app-1',
+	     *         uuid: 'app-1',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Application.start.html',
+	     *         autoShow: true
+	     *     });
+	     * }
+	     * start().then(() => console.log('Application is running')).catch(err => console.log(err));
+	     * ```
+	     *
+	     */
+	    async start(appOptions) {
+	        this.wire.sendAction('start-application').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        const app = await this._create(appOptions);
+	        await this.wire.sendAction('run-application', { uuid: appOptions.uuid });
+	        return app;
+	    }
+	    /**
+	     * Asynchronously starts a batch of applications given an array of application identifiers and manifestUrls.
+	     * Returns once the RVM is finished attempting to launch the applications.
+	     * @param opts - Parameters that the RVM will use.
+	     *
+	     * @example
+	     *
+	     * ```js
+	     *
+	     * const applicationInfoArray = [
+	     *     {
+	     *         "uuid": 'App-1',
+	     *         "manifestUrl": 'http://localhost:5555/app1.json',
+	     *     },
+	     *     {
+	     *         "uuid": 'App-2',
+	     *         "manifestUrl": 'http://localhost:5555/app2.json',
+	     *     },
+	     *     {
+	     *         "uuid": 'App-3',
+	     *         "manifestUrl": 'http://localhost:5555/app3.json',
+	     *     }
+	     * ]
+	     *
+	     * fin.Application.startManyManifests(applicationInfoArray)
+	     *     .then(() => {
+	     *         console.log('RVM has finished launching the application list.');
+	     *     })
+	     *     .catch((err) => {
+	     *         console.log(err);
+	     *     })
+	     * ```
+	     *
+	     * @experimental
+	     */
+	    async startManyManifests(applications, opts) {
+	        return this.wire.sendAction('run-applications', { applications, opts }).then(() => undefined);
+	    }
+	    /**
+	     * Asynchronously returns an Application object that represents the current application
+	     *
+	     * @example
+	     *
+	     * ```js
+	     * async function isCurrentAppRunning () {
+	     *     const app = await fin.Application.getCurrent();
+	     *     return app.isRunning();
+	     * }
+	     *
+	     * isCurrentAppRunning().then(running => {
+	     *     console.log(`Current app is running: ${running}`);
+	     * }).catch(err => {
+	     *     console.error(err);
+	     * });
+	     *
+	     * ```
+	     */
+	    getCurrent() {
+	        this.wire.sendAction('get-current-application').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        return this.wrap({ uuid: this.wire.me.uuid });
+	    }
+	    /**
+	     * Synchronously returns an Application object that represents the current application
+	     *
+	     * @example
+	     *
+	     * ```js
+	     * async function isCurrentAppRunning () {
+	     *     const app = fin.Application.getCurrentSync();
+	     *     return app.isRunning();
+	     * }
+	     *
+	     * isCurrentAppRunning().then(running => {
+	     *     console.log(`Current app is running: ${running}`);
+	     * }).catch(err => {
+	     *     console.error(err);
+	     * });
+	     *
+	     * ```
+	     */
+	    getCurrentSync() {
+	        this.wire.sendAction('get-current-application-sync').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        return this.wrapSync({ uuid: this.wire.me.uuid });
+	    }
+	    /**
+	     * Retrieves application's manifest and returns a running instance of the application.
+	     * @param manifestUrl - The URL of app's manifest.
+	     * @param opts - Parameters that the RVM will use.
+	     *
+	     * @example
+	     *
+	     * ```js
+	     * fin.Application.startFromManifest('http://localhost:5555/app.json').then(app => console.log('App is running')).catch(err => console.log(err));
+	     *
+	     * // For a local manifest file:
+	     * fin.Application.startFromManifest('file:///C:/somefolder/app.json').then(app => console.log('App is running')).catch(err => console.log(err));
+	     * ```
+	     */
+	    async startFromManifest(manifestUrl, opts) {
+	        this.wire.sendAction('application-start-from-manifest').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        const app = await this._createFromManifest(manifestUrl);
+	        // @ts-expect-error using private method without warning.
+	        await app._run(opts); // eslint-disable-line no-underscore-dangle
+	        return app;
+	    }
+	    /**
+	     * @deprecated Use {@link Application.ApplicationModule.startFromManifest Application.startFromManifest} instead.
+	     * Retrieves application's manifest and returns a wrapped application.
+	     * @param manifestUrl - The URL of app's manifest.
+	     * @param callback - called if the method succeeds.
+	     * @param errorCallback - called if the method fails. The reason for failure is passed as an argument.
+	     *
+	     * @example
+	     *
+	     * ```js
+	     * fin.Application.createFromManifest('http://localhost:5555/app.json').then(app => console.log(app)).catch(err => console.log(err));
+	     * ```
+	     * @ignore
+	     */
+	    createFromManifest(manifestUrl) {
+	        console.warn('Deprecation Warning: fin.Application.createFromManifest is deprecated. Please use fin.Application.startFromManifest');
+	        this.wire.sendAction('application-create-from-manifest').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        return this._createFromManifest(manifestUrl);
+	    }
+	    _createFromManifest(manifestUrl) {
+	        return this.wire
+	            .sendAction('get-application-manifest', { manifestUrl })
+	            .then(({ payload }) => {
+	            const uuid = payload.data.platform ? payload.data.platform.uuid : payload.data.startup_app.uuid;
+	            return this.wrap({ uuid });
+	        })
+	            .then((app) => {
+	            app._manifestUrl = manifestUrl; // eslint-disable-line no-underscore-dangle
+	            return app;
+	        });
+	    }
+	}
+	Factory$7.ApplicationModule = ApplicationModule;
+	return Factory$7;
+}
+
+var hasRequiredApplication;
+
+function requireApplication () {
+	if (hasRequiredApplication) return application;
+	hasRequiredApplication = 1;
+	(function (exports) {
+		var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    var desc = Object.getOwnPropertyDescriptor(m, k);
+		    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+		      desc = { enumerable: true, get: function() { return m[k]; } };
+		    }
+		    Object.defineProperty(o, k2, desc);
+		}) : (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    o[k2] = m[k];
+		}));
+		var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+		    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+		};
+		Object.defineProperty(exports, "__esModule", { value: true });
+		/**
+		 * Entry points for the OpenFin `Application` API (`fin.Application`).
+		 *
+		 * * {@link ApplicationModule} contains static members of the `Application` API, accessible through `fin.Application`.
+		 * * {@link Application} describes an instance of an OpenFin Application, e.g. as returned by `fin.Application.getCurrent`.
+		 *
+		 * These are separate code entities, and are documented separately.  In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/32.114.76.10/index.html),
+		 * both of these were documented on the same page.
+		 *
+		 * @packageDocumentation
+		 */
+		__exportStar(requireFactory$2(), exports);
+		__exportStar(requireInstance$1(), exports); 
+	} (application));
+	return application;
+}
+
+var promisifySubscription$1 = {};
+
+Object.defineProperty(promisifySubscription$1, "__esModule", { value: true });
+promisifySubscription$1.promisifySubscription = void 0;
+const promisifySubscription = async (emitter, eventName, predicate = () => true, timeout) => {
+    let resolve;
+    let reject;
+    let timer;
+    const valuePromise = new Promise((y, n) => {
+        resolve = y;
+        reject = n;
+    });
+    const listener = (e) => {
+        if (predicate(e)) {
+            clearTimeout(timer);
+            resolve(e);
+        }
+    };
+    await emitter.on(eventName, listener);
+    if (timeout) {
+        timer = setTimeout(() => reject(new Error('event timed out')), timeout);
+    }
+    valuePromise.finally(() => {
+        emitter.removeListener(eventName, listener).catch(() => null);
+    });
+    return {
+        getValue: () => valuePromise
+    };
+};
+promisifySubscription$1.promisifySubscription = promisifySubscription;
+
+var hasRequiredInstance;
+
+function requireInstance () {
+	if (hasRequiredInstance) return Instance$7;
+	hasRequiredInstance = 1;
+	Object.defineProperty(Instance$7, "__esModule", { value: true });
+	Instance$7._Window = void 0;
+	/* eslint-disable import/prefer-default-export */
+	/* eslint-disable @typescript-eslint/no-unused-vars */
+	/* eslint-disable no-console */
+	/* eslint-disable @typescript-eslint/no-non-null-assertion */
+	const application_1 = requireApplication();
+	const main_1 = main;
+	const view_1 = requireView();
+	const warnings_1 = warnings;
+	const promisifySubscription_1 = promisifySubscription$1;
+	/**
+	 * A basic window that wraps a native HTML window. Provides more fine-grained
+	 * control over the window state such as the ability to minimize, maximize, restore, etc.
+	 * By default a window does not show upon instantiation; instead the window's show() method
+	 * must be invoked manually. The new window appears in the same process as the parent window.
+	 * It has the ability to listen for {@link OpenFin.WindowEvents window specific events}.
+	 */
+	// The window.Window name is taken
+	class _Window extends main_1.WebContents {
+	    /**
+	     * @internal
+	     */
+	    constructor(wire, identity) {
+	        super(wire, identity, 'window');
+	    }
+	    async createWindow(options) {
+	        this.wire.sendAction('window-create-window', this.identity).catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        const CONSTRUCTOR_CB_TOPIC = 'fire-constructor-callback';
+	        const responseSubscription = await (0, promisifySubscription_1.promisifySubscription)(this, CONSTRUCTOR_CB_TOPIC);
+	        // set defaults:
+	        if (options.waitForPageLoad === undefined) {
+	            options.waitForPageLoad = false;
+	        }
+	        if (options.autoShow === undefined) {
+	            options.autoShow = true;
+	        }
+	        (0, warnings_1.handleDeprecatedWarnings)(options);
+	        const windowCreation = this.wire.environment.createChildContent({ entityType: 'window', options });
+	        const [response] = await Promise.all([responseSubscription.getValue(), windowCreation]);
+	        let cbPayload;
+	        const { success } = response;
+	        const responseData = response.data;
+	        const { message } = responseData;
+	        if (success) {
+	            cbPayload = {
+	                httpResponseCode: responseData.httpResponseCode,
+	                apiInjected: responseData.apiInjected
+	            };
+	        }
+	        else {
+	            cbPayload = {
+	                message: responseData.message,
+	                networkErrorCode: responseData.networkErrorCode,
+	                stack: responseData.stack
+	            };
+	        }
+	        const pageResolve = {
+	            message,
+	            cbPayload,
+	            success
+	        };
+	        try {
+	            // this is to enforce a 5.0 contract that the child's main function
+	            // will not fire before the parent's success callback on creation.
+	            // if the child window is not accessible (CORS) this contract does
+	            // not hold.
+	            const webWindow = this.getWebWindow();
+	            webWindow.fin.__internal_.openerSuccessCBCalled();
+	        }
+	        catch (e) {
+	            // common for main windows, we do not want to expose this error. here just to have a debug target.
+	            // console.error(e);
+	        }
+	        if (pageResolve.success) {
+	            return this;
+	        }
+	        return Promise.reject(pageResolve);
+	    }
+	    /**
+	     * Retrieves an array of frame info objects representing the main frame and any
+	     * iframes that are currently on the page.
+	     *
+	     * @example
+	     * ```js
+	     * async function getAllFrames() {
+	     *     const app = await fin.Application.start({
+	     *         name: 'myApp',
+	     *         uuid: 'app-1',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getAllFrames.html',
+	     *         autoShow: true
+	     *     });
+	     *     const win = await app.getWindow();
+	     *     return await win.getAllFrames();
+	     * }
+	     *
+	     * getAllFrames().then(framesInfo => console.log(framesInfo)).catch(err => console.log(err));
+	     * ```
+	     */
+	    getAllFrames() {
+	        return this.wire.sendAction('get-all-frames', this.identity).then(({ payload }) => payload.data);
+	    }
+	    /**
+	     * Gets the current bounds (top, bottom, right, left, width, height) of the window.
+	     *
+	     * @example
+	     * ```js
+	     * async function getBounds() {
+	     *     const app = await fin.Application.start({
+	     *         name: 'myApp',
+	     *         uuid: 'app-3',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getBounds.html',
+	     *         autoShow: true
+	     *     });
+	     *     const win = await app.getWindow();
+	     *     return await win.getBounds();
+	     * }
+	     *
+	     * getBounds().then(bounds => console.log(bounds)).catch(err => console.log(err));
+	     * ```
+	     */
+	    getBounds() {
+	        return this.wire
+	            .sendAction('get-window-bounds', this.identity)
+	            .then(({ payload }) => payload.data);
+	    }
+	    /**
+	     * Centers the window on its current screen.
+	     *
+	     * @remarks Does not have an effect on minimized or maximized windows.
+	     *
+	     * @example
+	     * ```js
+	     * async function centerWindow() {
+	     *     const app = await fin.Application.start({
+	     *         name: 'myApp',
+	     *         uuid: 'app-1',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.center.html',
+	     *         autoShow: true
+	     *     });
+	     *     const win = await app.getWindow();
+	     *     return await win.center();
+	     * }
+	     *
+	     * centerWindow().then(() => console.log('Window centered')).catch(err => console.log(err));
+	     * ```
+	     *
+	     */
+	    center() {
+	        return this.wire.sendAction('center-window', this.identity).then(() => undefined);
+	    }
+	    /**
+	     * Removes focus from the window.
+	     *
+	     * @example
+	     * ```js
+	     * async function blurWindow() {
+	     *     const app = await fin.Application.start({
+	     *         name: 'myApp',
+	     *         uuid: 'app-1',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.blur.html',
+	     *         autoShow: true
+	     *     });
+	     *     const win = await app.getWindow();
+	     *     return await win.blur();
+	     * }
+	     *
+	     * blurWindow().then(() => console.log('Blured Window')).catch(err => console.log(err));
+	     * ```
+	     */
+	    blur() {
+	        return this.wire.sendAction('blur-window', this.identity).then(() => undefined);
+	    }
+	    /**
+	     * Brings the window to the front of the window stack.
+	     *
+	     * @example
+	     * ```js
+	     * async function BringWindowToFront() {
+	     *     const app = await fin.Application.start({
+	     *         name: 'myApp',
+	     *         uuid: 'app-1',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.bringToFront.html',
+	     *         autoShow: true
+	     *     });
+	     *     const win = await app.getWindow();
+	     *     return await win.bringToFront();
+	     * }
+	     *
+	     * BringWindowToFront().then(() => console.log('Window is in the front')).catch(err => console.log(err));
+	     * ```
+	     */
+	    bringToFront() {
+	        return this.wire.sendAction('bring-window-to-front', this.identity).then(() => undefined);
+	    }
+	    /**
+	     * Performs the specified window transitions.
+	     * @param transitions - Describes the animations to perform. See the tutorial.
+	     * @param options - Options for the animation. See the tutorial.
+	     *
+	     * @example
+	     * ```
+	     * async function animateWindow() {
+	     *     const transitions = {
+	     *         opacity: {
+	     *             opacity: 0.7,
+	     *             duration: 500
+	     *         },
+	     *         position: {
+	     *             top: 100,
+	     *             left: 100,
+	     *             duration: 500,
+	     *             relative: true
+	     *         }
+	     *     };
+	     *     const options = {
+	     *         interrupt: true,
+	     *         tween: 'ease-in'
+	     *     };
+	     *
+	     *     const win = await fin.Window.getCurrent();
+	     *     return win.animate(transitions, options);
+	     * }
+	     *
+	     * animateWindow()
+	     *     .then(() => console.log('Animation done'))
+	     *     .catch(err => console.error(err));
+	     * ```
+	     */
+	    animate(transitions, options) {
+	        return this.wire
+	            .sendAction('animate-window', {
+	            transitions,
+	            options,
+	            ...this.identity
+	        })
+	            .then(() => undefined);
+	    }
+	    /**
+	     * Hides the window.
+	     *
+	     * @example
+	     * ```js
+	     * async function hideWindow() {
+	     *     const app = await fin.Application.start({
+	     *         name: 'myApp',
+	     *         uuid: 'app-1',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.hide.html',
+	     *         autoShow: true
+	     *     });
+	     *     const win = await app.getWindow();
+	     *     return await win.hide();
+	     * }
+	     *
+	     * hideWindow().then(() => console.log('Window is hidden')).catch(err => console.log(err));
+	     * ```
+	     */
+	    hide() {
+	        return this.wire.sendAction('hide-window', this.identity).then(() => undefined);
+	    }
+	    /**
+	     * closes the window application
+	     * @param force Close will be prevented from closing when force is false and
+	     *  ‘close-requested’ has been subscribed to for application’s main window.
+	     *
+	     * @example
+	     * ```js
+	     * async function closeWindow() {
+	     *     const app = await fin.Application.start({
+	     *         name: 'myApp',
+	     *         uuid: 'app-3',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.close.html',
+	     *         autoShow: true
+	     *     });
+	     *     const win = await app.getWindow();
+	     *     return await win.close();
+	     * }
+	     *
+	     * closeWindow().then(() => console.log('Window closed')).catch(err => console.log(err));
+	     * ```
+	     */
+	    close(force = false) {
+	        return this.wire.sendAction('close-window', { force, ...this.identity }).then(() => {
+	            Object.setPrototypeOf(this, null);
+	            return undefined;
+	        });
+	    }
+	    focusedWebViewWasChanged() {
+	        return this.wire.sendAction('focused-webview-changed', this.identity).then(() => undefined);
+	    }
+	    /**
+	     * Returns the native OS level Id.
+	     *
+	     * @remarks In Windows, it will return the Windows [handle](https://docs.microsoft.com/en-us/windows/desktop/WinProg/windows-data-types#HWND).
+	     *
+	     * @example
+	     * ```js
+	     * async function getWindowNativeId() {
+	     *     const app = await fin.Application.start({
+	     *         name: 'myApp',
+	     *         uuid: 'app-3',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getNativeId.html',
+	     *         autoShow: true
+	     *     });
+	     *     const win = await app.getWindow();
+	     *     return await win.getNativeId();
+	     * }
+	     *
+	     * getWindowNativeId().then(nativeId => console.log(nativeId)).catch(err => console.log(err));
+	     * ```
+	     */
+	    getNativeId() {
+	        return this.wire.sendAction('get-window-native-id', this.identity).then(({ payload }) => payload.data);
+	    }
+	    /**
+	     * Retrieves window's attached views.
+	     * @experimental
+	     *
+	     * @example
+	     * ```js
+	     * const win = fin.Window.getCurrentSync();
+	     *
+	     * win.getCurrentViews()
+	     *   .then(views => console.log(views))
+	     *   .catch(console.error);
+	     * ```
+	     */
+	    async getCurrentViews() {
+	        const { payload } = await this.wire.sendAction('window-get-views', this.identity);
+	        return payload.data.map((id) => new view_1.View(this.wire, id));
+	    }
+	    /**
+	     * @deprecated Use {@link Window._Window.disableUserMovement} instead.
+	     */
+	    disableFrame() {
+	        console.warn('Function is deprecated; use disableUserMovement instead.');
+	        return this.wire.sendAction('disable-window-frame', this.identity).then(() => undefined);
+	    }
+	    /**
+	     * Prevents a user from changing a window's size/position when using the window's frame.
+	     *
+	     * @example
+	     * ```js
+	     * async function disableUserMovement() {
+	     *     const app = await fin.Application.start({
+	     *         name: 'myApp',
+	     *         uuid: 'app-3',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.disableFrame.html',
+	     *         autoShow: true
+	     *     });
+	     *     const win = await app.getWindow();
+	     *     return await win.disableUserMovement();
+	     * }
+	     *
+	     * disableUserMovement().then(() => console.log('Window is disabled')).catch(err => console.log(err));
+	     * ```
+	     */
+	    disableUserMovement() {
+	        return this.wire.sendAction('disable-window-frame', this.identity).then(() => undefined);
+	    }
+	    /**
+	     * @deprecated Use {@link Window._Window.enableUserMovement} instead.
+	     */
+	    enableFrame() {
+	        console.warn('Function is deprecated; use enableUserMovement instead.');
+	        return this.wire.sendAction('enable-window-frame', this.identity).then(() => undefined);
+	    }
+	    /**
+	     * Re-enables user changes to a window's size/position when using the window's frame.
+	     *
+	     * @example
+	     * ```js
+	     * async function enableUserMovement() {
+	     *     const app = await fin.Application.start({
+	     *         name: 'myApp',
+	     *         uuid: 'app-3',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.enableFrame.html',
+	     *         autoShow: true
+	     *     });
+	     *     const win = await app.getWindow();
+	     *     return await win.enableUserMovement();
+	     * }
+	     *
+	     * enableUserMovement().then(() => console.log('Window is enabled')).catch(err => console.log(err));
+	     * ```
+	     */
+	    enableUserMovement() {
+	        return this.wire.sendAction('enable-window-frame', this.identity).then(() => undefined);
+	    }
+	    /**
+	     * Flashes the window’s frame and taskbar icon until stopFlashing is called or until a focus event is fired.
+	     *
+	     * @remarks On macOS flash only works on inactive windows.
+	     * @example
+	     * ```js
+	     * async function windowFlash() {
+	     *     const app = await fin.Application.start({
+	     *         name: 'myApp',
+	     *         uuid: 'app-1',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.flash.html',
+	     *         autoShow: true
+	     *     });
+	     *     const win = await app.getWindow();
+	     *     return await win.flash();
+	     * }
+	     *
+	     * windowFlash().then(() => console.log('Window flashing')).catch(err => console.log(err));
+	     * ```
+	     */
+	    flash() {
+	        return this.wire.sendAction('flash-window', this.identity).then(() => undefined);
+	    }
+	    /**
+	     * Stops the taskbar icon from flashing.
+	     *
+	     * @example
+	     * ```js
+	     * async function stopWindowFlashing() {
+	     *     const app = await fin.Application.start({
+	     *         name: 'myApp',
+	     *         uuid: 'app-1',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.stopFlashing.html',
+	     *         autoShow: true
+	     *     });
+	     *     const win = await app.getWindow();
+	     *     return await win.stopFlashing();
+	     * }
+	     *
+	     * stopWindowFlashing().then(() => console.log('Application window flashing')).catch(err => console.log(err));
+	     * ```
+	     */
+	    stopFlashing() {
+	        return this.wire.sendAction('stop-flash-window', this.identity).then(() => undefined);
+	    }
+	    /**
+	     * Gets an information object for the window.
+	     *
+	     * @example
+	     * ```js
+	     * async function getInfo() {
+	     *     const app = await fin.Application.start({
+	     *         name: 'myApp',
+	     *         uuid: 'app-1',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getInfo.html',
+	     *         autoShow: true
+	     *     });
+	     *     const win = await app.getWindow();
+	     *     return await win.getInfo();
+	     * }
+	     *
+	     * getInfo().then(info => console.log(info)).catch(err => console.log(err));
+	     * ```
+	     */
+	    getInfo() {
+	        return this.wire.sendAction('get-window-info', this.identity).then(({ payload }) => payload.data);
+	    }
+	    /**
+	     * Retrieves the window's Layout
+	     *
+	     * @example
+	     * ```js
+	     *     //get the current window
+	     *     const window = await fin.Window.getCurrent();
+	     *
+	     *     //get the layout for the window
+	     *     const layout = await window.getLayout();
+	     * ```
+	     * @experimental
+	     */
+	    async getLayout(layoutIdentity) {
+	        this.wire.sendAction('window-get-layout', this.identity).catch((e) => {
+	            // don't expose
+	        });
+	        const opts = await this.getOptions();
+	        if (!opts.layout && !opts.layoutSnapshot) {
+	            throw new Error('Window does not have a Layout');
+	        }
+	        return this.fin.Platform.Layout.wrap(layoutIdentity ?? this.identity);
+	    }
+	    /**
+	     * Gets the current settings of the window.
+	     *
+	     * @example
+	     * ```js
+	     * async function getWindowOptions() {
+	     *     const app = await fin.Application.start({
+	     *         name: 'myApp',
+	     *         uuid: 'app-1',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getOptions.html',
+	     *         autoShow: true
+	     *     });
+	     *     const win = await app.getWindow();
+	     *     return await win.getOptions();
+	     * }
+	     *
+	     * getWindowOptions().then(opts => console.log(opts)).catch(err => console.log(err));
+	     * ```
+	     */
+	    getOptions() {
+	        return this.wire.sendAction('get-window-options', this.identity).then(({ payload }) => payload.data);
+	    }
+	    /**
+	     * Gets the parent application.
+	     *
+	     * @example
+	     * ```js
+	     * async function getParentApplication() {
+	     *     const app = await fin.Application.start({
+	     *         name: 'myApp',
+	     *         uuid: 'app-1',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getParentApplication.html',
+	     *         autoShow: true
+	     *     });
+	     *     const win = await app.getWindow();
+	     *     return await win.getParentApplication();
+	     * }
+	     *
+	     * getParentApplication().then(parentApplication => console.log(parentApplication)).catch(err => console.log(err));
+	     * ```
+	     */
+	    getParentApplication() {
+	        this.wire.sendAction('window-get-parent-application', this.identity).catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        return Promise.resolve(new application_1.Application(this.wire, this.identity));
+	    }
+	    /**
+	     * Gets the parent window.
+	     *
+	     * @example
+	     * ```js
+	     * async function getParentWindow() {
+	     *     const app = await fin.Application.start({
+	     *         name: 'myApp',
+	     *         uuid: 'app-1',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getParentWindow.html',
+	     *         autoShow: true
+	     *     });
+	     *     const win = await app.getWindow();
+	     *     return await win.getParentWindow();
+	     * }
+	     *
+	     * getParentWindow().then(parentWindow => console.log(parentWindow)).catch(err => console.log(err));
+	     * ```
+	     */
+	    getParentWindow() {
+	        this.wire.sendAction('window-get-parent-window', this.identity).catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        return Promise.resolve(new application_1.Application(this.wire, this.identity)).then((app) => app.getWindow());
+	    }
+	    /**
+	     * ***DEPRECATED - please use Window.capturePage.***
+	     * Gets a base64 encoded PNG image of the window or just part a of it.
+	     * @param area The area of the window to be captured.
+	     * Omitting it will capture the whole visible window.
+	     *
+	     * @tutorial Window.capturePage
+	     */
+	    async getSnapshot(area) {
+	        const req = { area, ...this.identity };
+	        console.warn('Window.getSnapshot has been deprecated, please use Window.capturePage');
+	        const res = await this.wire.sendAction('get-window-snapshot', req);
+	        return res.payload.data;
+	    }
+	    /**
+	     * Gets the current state ("minimized", "maximized", or "normal") of the window.
+	     *
+	     * @example
+	     * ```js
+	     * async function getWindowState() {
+	     *     const app = await fin.Application.start({
+	     *         name: 'myApp',
+	     *         uuid: 'app-1',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getState.html',
+	     *         autoShow: true
+	     *     });
+	     *     const win = await app.getWindow();
+	     *     return await win.getState();
+	     * }
+	     *
+	     * getWindowState().then(winState => console.log(winState)).catch(err => console.log(err));
+	     * ```
+	     */
+	    getState() {
+	        return this.wire.sendAction('get-window-state', this.identity).then(({ payload }) => payload.data);
+	    }
+	    /**
+	     * Previously called getNativeWindow.
+	     * Returns the [Window Object](https://developer.mozilla.org/en-US/docs/Web/API/Window)
+	     * that represents the web context of the target window. This is the same object that
+	     * you would get from calling [window.open()](https://developer.mozilla.org/en-US/docs/Web/API/Window/open) in a standard web context.
+	     * The target window needs to be in the same application as the requesting window
+	     * as well as comply with [same-origin](https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy) policy requirements.
+	     *
+	     * @example
+	     * Injecting content into an empty window:
+	     *
+	     * ```js
+	     * (async ()=> {
+	     *     try {
+	     *         const winName = `child-window-${Date.now()}`;
+	     *         const win = await fin.Window.create({
+	     *             name: winName,
+	     *             url: 'about:blank'
+	     *         });
+	     *         win.getWebWindow().document.write('
Hello World
');
+	     *     } catch (err) {
+	     *         console.error(err);
+	     *     }
+	     * })();
+	     * ```
+	     *
+	     * Cloning DOM elements from the parent window (in this example we clone an `h3` element from the parent window):
+	     * ```js
+	     * (async ()=> {
+	     *     try {
+	     *         const currentWindow = await fin.Window.getCurrent();
+	     *         const parentWindow = await currentWindow.getParentWindow();
+	     *         const clonedH3 = parentWindow.getWebWindow().document.querySelector('h3').cloneNode(true);
+	     *         document.body.append(clonedH3);
+	     *
+	     *     } catch (err) {
+	     *         console.error(err);
+	     *     }
+	     * })();
+	     * ```
+	     *
+	     * Rendering on a child window via a library (in this example we are using the [lit-html](https://lit-html.polymer-project.org/)
+	     * template library to render content on a blank child window. You are not going to be able to copy paste this example without
+	     * configuring the project correctly but this would demonstrate some templating options available):
+	     * ```js
+	     * (async ()=> {
+	     *     try {
+	     *         const win = await fin.Window.create({
+	     *             name: `child-window-${Date.now()}`,
+	     *             url: 'about:blank'
+	     *         });
+	     *         const template = html`
+	     *             

+	     *                 Click here: 
+	     *                 
+	     *             
`;
+	     *         render(template, win.getWebWindow().document.body);
+	     *
+	     *     } catch (err) {
+	     *         console.error(err);
+	     *     }
+	     * })();
+	     * ```
+	     */
+	    getWebWindow() {
+	        this.wire.sendAction('window-get-web-window', this.identity).catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        return this.wire.environment.getWebWindow(this.identity);
+	    }
+	    /**
+	     * Determines if the window is a main window.
+	     *
+	     * @example
+	     * ```js
+	     * const wnd = fin.Window.getCurrentSync();
+	     * const isMainWnd = wnd.isMainWindow();
+	     * console.log('Is this a main window? ' + isMainWnd);
+	     * ```
+	     */
+	    isMainWindow() {
+	        this.wire.sendAction('window-is-main-window', this.identity).catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        return this.me.uuid === this.me.name;
+	    }
+	    /**
+	     * Determines if the window is currently showing.
+	     *
+	     * @example
+	     * ```js
+	     * async function isWindowShowing() {
+	     *     const app = await fin.Application.start({
+	     *         name: 'myApp',
+	     *         uuid: 'app-1',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.isShowing.html',
+	     *         autoShow: true
+	     *     });
+	     *     const win = await app.getWindow();
+	     *     return await win.isShowing();
+	     * }
+	     *
+	     * isWindowShowing().then(bool => console.log(bool)).catch(err => console.log(err));
+	     * ```
+	     */
+	    isShowing() {
+	        return this.wire.sendAction('is-window-showing', this.identity).then(({ payload }) => payload.data);
+	    }
+	    /**
+	     * Maximizes the window
+	     *
+	     * @example
+	     * ```js
+	     * async function maxWindow() {
+	     *     const app = await fin.Application.start({
+	     *         name: 'myApp',
+	     *         uuid: 'app-1',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.maximize.html',
+	     *         autoShow: true
+	     *     });
+	     *     const win = await app.getWindow();
+	     *     return await win.maximize();
+	     * }
+	     *
+	     * maxWindow().then(() => console.log('Maximized window')).catch(err => console.log(err));
+	     * ```
+	     */
+	    maximize() {
+	        return this.wire.sendAction('maximize-window', this.identity).then(() => undefined);
+	    }
+	    /**
+	     * Minimizes the window.
+	     *
+	     * @example
+	     * ```js
+	     * async function minWindow() {
+	     *     const win = await fin.Window.getCurrent();
+	     *     return await win.minimize();
+	     * }
+	     *
+	     * minWindow().then(() => console.log('Minimized window')).catch(err => console.log(err));
+	     * ```
+	     */
+	    minimize() {
+	        return this.wire.sendAction('minimize-window', this.identity).then(() => undefined);
+	    }
+	    /**
+	     * Moves the window by a specified amount.
+	     * @param deltaLeft The change in the left position of the window
+	     * @param deltaTop The change in the top position of the window
+	     *
+	     * @example
+	     * ```js
+	     * async function createWin() {
+	     *     const app = await fin.Application.start({
+	     *         name: 'myApp',
+	     *         uuid: 'app-1',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.moveBy.html',
+	     *         autoShow: true
+	     *     });
+	     *     return await app.getWindow();
+	     * }
+	     *
+	     * async function moveBy(left, top) {
+	     *     const win = await createWin();
+	     *     return await win.moveBy(left, top);
+	     * }
+	     *
+	     * moveBy(580, 300).then(() => console.log('Moved')).catch(err => console.log(err));
+	     * ```
+	     */
+	    moveBy(deltaLeft, deltaTop, positioningOptions) {
+	        return this.wire
+	            .sendAction('move-window-by', {
+	            deltaLeft,
+	            deltaTop,
+	            positioningOptions,
+	            ...this.identity
+	        })
+	            .then(() => undefined);
+	    }
+	    /**
+	     * Moves the window to a specified location.
+	     * @param left The left position of the window
+	     * @param top The top position of the window
+	     *
+	     * @example
+	     * ```js
+	     * async function createWin() {
+	     *     const app = await fin.Application.start({
+	     *         name: 'myApp',
+	     *         uuid: 'app-1',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.moveTo.html',
+	     *         autoShow: true
+	     *     });
+	     *     return await app.getWindow();
+	     * }
+	     *
+	     * async function moveTo(left, top) {
+	     *     const win = await createWin();
+	     *     return await win.moveTo(left, top)
+	     * }
+	     *
+	     * moveTo(580, 300).then(() => console.log('Moved')).catch(err => console.log(err))
+	     * ```
+	     */
+	    moveTo(left, top, positioningOptions) {
+	        return this.wire
+	            .sendAction('move-window', {
+	            left,
+	            top,
+	            positioningOptions,
+	            ...this.identity
+	        })
+	            .then(() => undefined);
+	    }
+	    /**
+	     * Resizes the window by a specified amount.
+	     * @param deltaWidth The change in the width of the window
+	     * @param deltaHeight The change in the height of the window
+	     * @param anchor Specifies a corner to remain fixed during the resize.
+	     * Can take the values: "top-left", "top-right", "bottom-left", or "bottom-right".
+	     * If undefined, the default is "top-left"
+	     *
+	     * @example
+	     * ```js
+	     * async function createWin() {
+	     *     const app = await fin.Application.start({
+	     *         name: 'myApp',
+	     *         uuid: 'app-1',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.resizeBy.html',
+	     *         autoShow: true
+	     *     });
+	     *     return await app.getWindow();
+	     * }
+	     *
+	     * async function resizeBy(left, top, anchor) {
+	     *     const win = await createWin();
+	     *     return await win.resizeBy(left, top, anchor)
+	     * }
+	     *
+	     * resizeBy(580, 300, 'top-right').then(() => console.log('Resized')).catch(err => console.log(err));
+	     * ```
+	     */
+	    resizeBy(deltaWidth, deltaHeight, anchor, positioningOptions) {
+	        return this.wire
+	            .sendAction('resize-window-by', {
+	            deltaWidth: Math.floor(deltaWidth),
+	            deltaHeight: Math.floor(deltaHeight),
+	            anchor,
+	            positioningOptions,
+	            ...this.identity
+	        })
+	            .then(() => undefined);
+	    }
+	    /**
+	     * Resizes the window to the specified dimensions.
+	     * @param width The change in the width of the window
+	     * @param height The change in the height of the window
+	     * @param anchor Specifies a corner to remain fixed during the resize.
+	     * Can take the values: "top-left", "top-right", "bottom-left", or "bottom-right".
+	     * If undefined, the default is "top-left"
+	     *
+	     * @example
+	     * ```js
+	     * async function createWin() {
+	     *     const app = await fin.Application.start({
+	     *         name: 'myApp',
+	     *         uuid: 'app-1',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.resizeTo.html',
+	     *         autoShow: true
+	     *     });
+	     *     return await app.getWindow();
+	     * }
+	     *
+	     * async function resizeTo(left, top, anchor) {
+	     *     const win = await createWin();
+	     *     return await win.resizeTo(left, top, anchor);
+	     * }
+	     *
+	     * resizeTo(580, 300, 'top-left').then(() => console.log('Resized')).catch(err => console.log(err));
+	     * ```
+	     */
+	    resizeTo(width, height, anchor, positioningOptions) {
+	        return this.wire
+	            .sendAction('resize-window', {
+	            width: Math.floor(width),
+	            height: Math.floor(height),
+	            anchor,
+	            positioningOptions,
+	            ...this.identity
+	        })
+	            .then(() => undefined);
+	    }
+	    /**
+	     * Restores the window to its normal state (i.e., unminimized, unmaximized).
+	     *
+	     * @example
+	     * ```js
+	     * async function createWin() {
+	     *     const app = await fin.Application.start({
+	     *         name: 'myApp',
+	     *         uuid: 'app-1',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.restore.html',
+	     *         autoShow: true
+	     *     });
+	     *     return await app.getWindow();
+	     * }
+	     *
+	     * async function restore() {
+	     *     const win = await createWin();
+	     *     return await win.restore();
+	     * }
+	     *
+	     * restore().then(() => console.log('Restored')).catch(err => console.log(err));
+	     * ```
+	     */
+	    restore() {
+	        return this.wire.sendAction('restore-window', this.identity).then(() => undefined);
+	    }
+	    /**
+	     * Will bring the window to the front of the entire stack and give it focus.
+	     *
+	     * @example
+	     * ```js
+	     * async function createWin() {
+	     *     const app = await fin.Application.start({
+	     *         name: 'myApp',
+	     *         uuid: 'app-1',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.setAsForeground.html',
+	     *         autoShow: true
+	     *     });
+	     *     return await app.getWindow();
+	     * }
+	     *
+	     * async function setAsForeground() {
+	     *     const win = await createWin();
+	     *     return await win.setAsForeground()
+	     * }
+	     *
+	     * setAsForeground().then(() => console.log('In the foreground')).catch(err => console.log(err));
+	     * ```
+	     */
+	    setAsForeground() {
+	        return this.wire.sendAction('set-foreground-window', this.identity).then(() => undefined);
+	    }
+	    /**
+	     * Sets the window's size and position.
+	     *
+	     * @example
+	     * ```js
+	     * async function createWin() {
+	     *     const app = await fin.Application.start({
+	     *         name: 'myApp',
+	     *         uuid: 'app-1',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.setBounds.html',
+	     *         autoShow: true
+	     *     });
+	     *     return await app.getWindow();
+	     * }
+	     *
+	     * async function setBounds(bounds) {
+	     *     const win = await createWin();
+	     *     return await win.setBounds(bounds);
+	     * }
+	     *
+	     * setBounds({
+	     *     height: 100,
+	     *     width: 200,
+	     *     top: 400,
+	     *     left: 400
+	     * }).then(() => console.log('Bounds set to window')).catch(err => console.log(err));
+	     * ```
+	     */
+	    setBounds(bounds, positioningOptions) {
+	        return this.wire
+	            .sendAction('set-window-bounds', { ...bounds, ...this.identity, positioningOptions })
+	            .then(() => undefined);
+	    }
+	    /**
+	     * Shows the window if it is hidden.
+	     * @param force Show will be prevented from showing when force is false and
+	     *  ‘show-requested’ has been subscribed to for application’s main window.
+	     *
+	     * @example
+	     * ```js
+	     * async function createWin() {
+	     *     const app = await fin.Application.start({
+	     *         name: 'myApp',
+	     *         uuid: 'app-1',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.show.html',
+	     *         autoShow: false
+	     *     });
+	     *     return await app.getWindow();
+	     * }
+	     *
+	     * async function show() {
+	     *     const win = await createWin();
+	     *     return await win.show()
+	     * }
+	     *
+	     * show().then(() => console.log('Showing')).catch(err => console.log(err));
+	     * ```
+	     */
+	    show(force = false) {
+	        return this.wire.sendAction('show-window', { force, ...this.identity }).then(() => undefined);
+	    }
+	    /**
+	     * Shows the window if it is hidden at the specified location.
+	     *
+	     * @param left The left position of the window in pixels
+	     * @param top The top position of the window in pixels
+	     * @param force Show will be prevented from closing when force is false and
+	     * ‘show-requested’ has been subscribed to for application’s main window
+	     *
+	     * @example
+	     * ```js
+	     * async function createWin() {
+	     *     const app = await fin.Application.start({
+	     *         name: 'myApp',
+	     *         uuid: 'app-1',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.showAt.html',
+	     *         autoShow: true
+	     *     });
+	     *     return await app.getWindow();
+	     * }
+	     *
+	     * async function showAt(left, top) {
+	     *     const win = await createWin();
+	     *     return await win.showAt(left, top)
+	     * }
+	     *
+	     * showAt(580, 300).then(() => console.log('Showing at')).catch(err => console.log(err));
+	     * ```
+	     */
+	    showAt(left, top, force = false) {
+	        return this.wire
+	            .sendAction('show-at-window', {
+	            force,
+	            left: Math.floor(left),
+	            top: Math.floor(top),
+	            ...this.identity
+	        })
+	            .then(() => undefined);
+	    }
+	    /**
+	     * Shows the Chromium Developer Tools
+	     *
+	     * @tutorial Window.showDeveloperTools
+	     */
+	    /**
+	     * Updates the window using the passed options.
+	     *
+	     * @remarks Values that are objects are deep-merged, overwriting only the values that are provided.
+	     * @param options Changes a window's options that were defined upon creation. See tutorial
+	     *
+	     * @example
+	     * ```js
+	     * async function updateOptions() {
+	     *     const win = await fin.Window.getCurrent();
+	     *     return win.updateOptions({maxWidth: 100});
+	     * }
+	     * updateOptions().then(() => console.log('options is updated')).catch(err => console.error(err));
+	     * ```
+	     */
+	    updateOptions(options) {
+	        return this.wire.sendAction('update-window-options', { options, ...this.identity }).then(() => undefined);
+	    }
+	    /**
+	     * Provides credentials to authentication requests
+	     * @param userName userName to provide to the authentication challenge
+	     * @param password password to provide to the authentication challenge
+	     *
+	     * @example
+	     * ```js
+	     * fin.Application.wrap({uuid: 'OpenfinPOC'}).then(app => {
+	     *     app.on('window-auth-requested', evt => {
+	     *         let win = fin.Window.wrap({ uuid: evt.uuid, name: evt.name});
+	     *         win.authenticate('userName', 'P@assw0rd').then(()=> console.log('authenticated')).catch(err => console.log(err));
+	     *     });
+	     * });
+	     * ```
+	     */
+	    authenticate(userName, password) {
+	        return this.wire
+	            .sendAction('window-authenticate', { userName, password, ...this.identity })
+	            .then(() => undefined);
+	    }
+	    /**
+	     * Shows a menu on the window.
+	     *
+	     * @remarks Returns a promise that resolves when the user has either selected an item or closed the menu. (This may take longer than other apis).
+	     * Resolves to an object with `{result: 'clicked', data }` where data is the data field on the menu item clicked, or `{result 'closed'}` when the user doesn't select anything.
+	     * Calling this method will close previously opened menus.
+	     * @experimental
+	     * @param options
+	     * @typeParam Data User-defined shape for data returned upon menu item click.  Should be a
+	     * [union](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#union-types)
+	     * of all possible data shapes for the entire menu, and the click handler should process
+	     * these with a "reducer" pattern.
+	     * @example
+	     * This could be used to show a drop down menu over views in a platform window:
+	     * ```js
+	     * const template = [
+	     *     {
+	     *         label: 'Menu Item 1',
+	     *         data: 'hello from item 1'
+	     *     },
+	     *     { type: 'separator' },
+	     *     {
+	     *         label: 'Menu Item 2',
+	     *         type: 'checkbox',
+	     *         checked: true,
+	     *         data: 'The user clicked the checkbox'
+	     *     },
+	     *     {
+	     *         label: 'see more',
+	     *         enabled: false,
+	     *         submenu: [
+	     *             { label: 'submenu 1', data: 'hello from submenu' }
+	     *         ]
+	     *     }
+	     * ]
+	     * fin.me.showPopupMenu({ template }).then(r => {
+	     *     if (r.result === 'closed') {
+	     *         console.log('nothing happened');
+	     *     } else {
+	     *         console.log(r.data)
+	     *     }
+	     * })
+	     * ```
+	     *
+	     * Overriding the built in context menu (note: that this can be done per element or document wide):
+	     * ```js
+	     * document.addEventListener('contextmenu', e => {
+	     *     e.preventDefault();
+	     *     const template = [
+	     *         {
+	     *             label: 'Menu Item 1',
+	     *             data: 'hello from item 1'
+	     *         },
+	     *         { type: 'separator' },
+	     *         {
+	     *             label: 'Menu Item 2',
+	     *             type: 'checkbox',
+	     *             checked: true,
+	     *             data: 'The user clicked the checkbox'
+	     *         },
+	     *         {
+	     *             label: 'see more',
+	     *             enabled: false,
+	     *             submenu: [
+	     *                 { label: 'submenu 1', data: 'hello from submenu' }
+	     *             ]
+	     *         }
+	     *     ]
+	     *     fin.me.showPopupMenu({ template, x: e.x, y: e.y }).then(r => {
+	     *         if (r.result === 'closed') {
+	     *             console.log('nothing happened');
+	     *         } else {
+	     *             console.log(r.data)
+	     *         }
+	     *     })
+	     * })
+	     * ```
+	     */
+	    async showPopupMenu(options) {
+	        const { payload } = await this.wire.sendAction('show-popup-menu', { options, ...this.identity });
+	        return payload.data;
+	    }
+	    /**
+	     * Closes the window's popup menu, if one exists.
+	     * @experimental
+	     *
+	     * @remarks Only one popup menu will ever be showing at a time. Calling `showPopupMenu` will automatically close
+	     * any existing popup menu.
+	     *
+	     *
+	     * @example
+	     * This could be used to close a popup menu if the user's mouse leaves an element for example.
+	     *
+	     * ```js
+	     * await fin.me.closePopupMenu();
+	     * ```
+	     */
+	    async closePopupMenu() {
+	        return this.wire.sendAction('close-popup-menu', { ...this.identity }).then(() => undefined);
+	    }
+	    /**
+	     * Dispatch a result to the caller of `showPopupWindow`.
+	     *
+	     * @remarks If this window isn't currently being shown as a popup, this call will silently fail.
+	     * @param data Serializable data to send to the caller window.
+	     *
+	     * @example
+	     * ```js
+	     * await fin.me.dispatchPopupResult({
+	     *     foo: 'bar'
+	     * });
+	     * ```
+	     */
+	    async dispatchPopupResult(data) {
+	        this.wire.sendAction('window-dispatch-popup-result', this.identity).catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        await this.wire.sendAction('dispatch-popup-result', { data, ...this.identity });
+	    }
+	    /**
+	     * Prints the contents of the window.
+	     *
+	     * @param options Configuration for the print task.
+	     * @remarks When `silent` is set to `true`, the API will pick the system's default printer if deviceName is empty
+	     * and the default settings for printing.
+	     *
+	     * Use the CSS style `page-break-before: always;` to force print to a new page.
+	     *
+	     * @example
+	     * ```js
+	     * const win = fin.Window.getCurrentSync();
+	     *
+	     * win.print({ silent: false, deviceName: 'system-printer-name' }).then(() => {
+	     *     console.log('print call has been sent to the system');
+	     * });
+	     * ```
+	     *
+	     * If a window has embedded views, those views will not print by default.  To print a window's contents including embedded views,
+	     * use the `content` option:
+	     *
+	     * ```js
+	     * const win = fin.Window.getCurrentSync();
+	     *
+	     * // Print embedded views
+	     * win.print({ content: 'views' });
+	     *
+	     * // Print screenshot of current window
+	     * win.print({ content: 'screenshot' })
+	     * ```
+	     *
+	     * When `content` is set to `views`, the embedded views in the platform window will be concatenated and printed as
+	     * individual pages.  If `includeSelf` is set to `true`, the platform window itself will be printed as the first
+	     * page - be aware that this page will *not* include the embedded views - it will only include the contents of
+	     * the platform window itself (e.g. tab stacks), with blank spaces where the view contents would be embedded.
+	     *
+	     * Due to a known issue, view contents that are not visible at the time `print` is called will not appear when
+	     * printing `contents: views`.  This includes views that are obscured behind other active UI elements.
+	     *
+	     * To print the views embedded in their page context, set `content` to `screenshot`.
+	     */
+	    async print(options = { content: 'self' }) {
+	        switch (options.content) {
+	            case undefined:
+	            case 'self':
+	                return super.print(options);
+	            case 'screenshot':
+	                return this.wire.sendAction('print-screenshot', this.identity).then(() => undefined);
+	            case 'views':
+	                return this.wire.sendAction('print-views', { ...this.identity, options }).then(() => undefined);
+	            default:
+	                return undefined;
+	        }
+	    }
+	}
+	Instance$7._Window = _Window;
+	return Instance$7;
+}
+
+var hasRequiredFactory$1;
+
+function requireFactory$1 () {
+	if (hasRequiredFactory$1) return Factory$8;
+	hasRequiredFactory$1 = 1;
+	Object.defineProperty(Factory$8, "__esModule", { value: true });
+	Factory$8._WindowModule = void 0;
+	const base_1 = base;
+	const validate_1 = validate;
+	const Instance_1 = requireInstance();
+	/**
+	 * Static namespace for OpenFin API methods that interact with the {@link _Window} class, available under `fin.Window`.
+	 */
+	class _WindowModule extends base_1.Base {
+	    /**
+	     * Asynchronously returns an API handle for the given Window identity.
+	     *
+	     * @remarks Wrapping a Window identity that does not yet exist will *not* throw an error, and instead
+	     * returns a stub object that cannot yet perform rendering tasks. This can be useful for plumbing eventing
+	     * for a Window throughout its entire lifecycle.
+	     *
+	     * @example
+	     * ```js
+	     * async function createWin() {
+	     *     const app = await fin.Application.start({
+	     *         name: 'myApp',
+	     *         uuid: 'app-1',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.wrap.html',
+	     *         autoShow: true
+	     *     });
+	     *     return await app.getWindow();
+	     * }
+	     * createWin().then(() => fin.Window.wrap({ uuid: 'app-1', name: 'myApp' }))
+	     * .then(win => console.log('wrapped window'))
+	     * .catch(err => console.log(err));
+	     * ```
+	     */
+	    async wrap(identity) {
+	        this.wire.sendAction('window-wrap').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        const errorMsg = (0, validate_1.validateIdentity)(identity);
+	        if (errorMsg) {
+	            throw new Error(errorMsg);
+	        }
+	        return new Instance_1._Window(this.wire, identity);
+	    }
+	    /**
+	     * Synchronously returns an API handle for the given Window identity.
+	     *
+	     * @remarks Wrapping a Window identity that does not yet exist will *not* throw an error, and instead
+	     * returns a stub object that cannot yet perform rendering tasks. This can be useful for plumbing eventing
+	     * for a Window throughout its entire lifecycle.
+	     *
+	     * @example
+	     * ```js
+	     * async function createWin() {
+	     *     const app = await fin.Application.start({
+	     *         name: 'myApp',
+	     *         uuid: 'app-1',
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.wrapSync.html',
+	     *         autoShow: true
+	     *     });
+	     *     return await app.getWindow();
+	     * }
+	     * await createWin();
+	     * let win = fin.Window.wrapSync({ uuid: 'app-1', name: 'myApp' });
+	     * ```
+	     */
+	    wrapSync(identity) {
+	        this.wire.sendAction('window-wrap-sync').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        const errorMsg = (0, validate_1.validateIdentity)(identity);
+	        if (errorMsg) {
+	            throw new Error(errorMsg);
+	        }
+	        return new Instance_1._Window(this.wire, identity);
+	    }
+	    /**
+	     * Creates a new Window.
+	     * @param options - Window creation options
+	     *
+	     * @example
+	     * ```js
+	     * async function createWindow() {
+	     *     const winOption = {
+	     *         name:'child',
+	     *         defaultWidth: 300,
+	     *         defaultHeight: 300,
+	     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.create.html',
+	     *         frame: true,
+	     *         autoShow: true
+	     *     };
+	     *     return await fin.Window.create(winOption);
+	     * }
+	     *
+	     * createWindow().then(() => console.log('Window is created')).catch(err => console.log(err));
+	     * ```
+	     */
+	    create(options) {
+	        this.wire.sendAction('create-window').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        const win = new Instance_1._Window(this.wire, { uuid: this.me.uuid, name: options.name });
+	        return win.createWindow(options);
+	    }
+	    /**
+	     * Asynchronously returns a Window object that represents the current window
+	     *
+	     * @example
+	     * ```js
+	     * fin.Window.getCurrent()
+	     * .then(wnd => console.log('current window'))
+	     * .catch(err => console.log(err));
+	     *
+	     * ```
+	     */
+	    getCurrent() {
+	        this.wire.sendAction('get-current-window').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        if (!this.wire.me.isWindow) {
+	            throw new Error('You are not in a Window context');
+	        }
+	        const { uuid, name } = this.wire.me;
+	        return this.wrap({ uuid, name });
+	    }
+	    /**
+	     * Synchronously returns a Window object that represents the current window
+	     *
+	     * @example
+	     * ```js
+	     * const wnd = fin.Window.getCurrentSync();
+	     * const info = await wnd.getInfo();
+	     * console.log(info);
+	     *
+	     * ```
+	     */
+	    getCurrentSync() {
+	        this.wire.sendAction('get-current-window-sync').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        if (!this.wire.me.isWindow) {
+	            throw new Error('You are not in a Window context');
+	        }
+	        const { uuid, name } = this.wire.me;
+	        return this.wrapSync({ uuid, name });
+	    }
+	}
+	Factory$8._WindowModule = _WindowModule;
+	return Factory$8;
+}
+
+var hasRequiredWindow;
+
+function requireWindow () {
+	if (hasRequiredWindow) return window$1;
+	hasRequiredWindow = 1;
+	(function (exports) {
+		var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    var desc = Object.getOwnPropertyDescriptor(m, k);
+		    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+		      desc = { enumerable: true, get: function() { return m[k]; } };
+		    }
+		    Object.defineProperty(o, k2, desc);
+		}) : (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    o[k2] = m[k];
+		}));
+		var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+		    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+		};
+		Object.defineProperty(exports, "__esModule", { value: true });
+		/**
+		 * Entry points for the OpenFin `Window` API (`fin.Window`).
+		 *
+		 * * {@link _WindowModule} contains static members of the `Window` API, accessible through `fin.Window`.
+		 * * {@link _Window} describes an instance of an OpenFin Window, e.g. as returned by `fin.Window.getCurrent`.
+		 *
+		 * These are separate code entities, and are documented separately.  In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/32.114.76.10/index.html),
+		 * both of these were documented on the same page.
+		 *
+		 * Underscore prefixing of OpenFin types that alias DOM entities will be fixed in a future version.
+		 *
+		 * @packageDocumentation
+		 */
+		__exportStar(requireFactory$1(), exports);
+		__exportStar(requireInstance(), exports); 
+	} (window$1));
+	return window$1;
+}
+
+/**
+ * Entry point for the OpenFin `System` API (`fin.System`).
+ *
+ * * {@link System} contains static members of the `System` API (available under `fin.System`)
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(system, "__esModule", { value: true });
+system.System = void 0;
+const base_1$i = base;
+const transport_errors_1$1 = transportErrors;
+const window_1 = requireWindow();
+const events_1$6 = require$$0;
+/**
+ * An object representing the core of OpenFin Runtime. Allows the developer
+ * to perform system-level actions, such as accessing logs, viewing processes,
+ * clearing the cache and exiting the runtime as well as listen to {@link OpenFin.SystemEvents system events}.
+ *
+ */
+class System extends base_1$i.EmitterBase {
+    /**
+     * @internal
+     */
+    constructor(wire) {
+        super(wire, 'system');
+    }
+    sendExternalProcessRequest(action, options) {
+        return new Promise((resolve, reject) => {
+            const exitEventKey = 'external-process-exited';
+            let processUuid;
+            let exitPayload;
+            let externalProcessExitHandler;
+            let ofWindow;
+            if (typeof options.listener === 'function') {
+                externalProcessExitHandler = (payload) => {
+                    const data = payload || {};
+                    exitPayload = {
+                        topic: 'exited',
+                        uuid: data.processUuid || '',
+                        exitCode: data.exitCode || 0
+                    };
+                    if (processUuid === payload.processUuid) {
+                        options.listener(exitPayload);
+                        ofWindow.removeListener(exitEventKey, externalProcessExitHandler);
+                    }
+                };
+                // window constructor expects the name is not undefined
+                if (!this.wire.me.name) {
+                    this.wire.me.name = this.wire.me.uuid;
+                }
+                ofWindow = new window_1._Window(this.wire, this.wire.me);
+                ofWindow.on(exitEventKey, externalProcessExitHandler);
+            }
+            this.wire
+                .sendAction(action, options)
+                .then(({ payload }) => {
+                processUuid = payload.data.uuid;
+                resolve(payload.data);
+                if (exitPayload && processUuid === exitPayload.uuid) {
+                    options.listener(exitPayload);
+                    ofWindow.removeListener(exitEventKey, externalProcessExitHandler);
+                }
+            })
+                .catch((err) => {
+                if (ofWindow) {
+                    ofWindow.removeListener(exitEventKey, externalProcessExitHandler);
+                }
+                reject(err);
+            });
+        });
+    }
+    /**
+     * Returns the version of the runtime. The version contains the major, minor,
+     * build and revision numbers.
+     *
+     * @example
+     * ```js
+     * fin.System.getVersion().then(v => console.log(v)).catch(err => console.log(err));
+     * ```
+     */
+    getVersion() {
+        return this.wire.sendAction('get-version').then(({ payload }) => payload.data);
+    }
+    /**
+     * Clears cached data containing application resource
+     * files (images, HTML, JavaScript files), cookies, and items stored in the
+     * Local Storage.
+     * @param options - See below for details.
+     *
+     * @remarks For more information on the accepted options, see the following pages:
+     * * cache: browsing data cache for html files and images ([caching](https://developer.mozilla.org/en-US/docs/Web/HTTP/Caching))
+     * * cookies: browser [cookies](https://developer.mozilla.org/en-US/docs/Web/HTTP/Cookies)
+     * * localStorage: browser data that can be used across sessions ([local storage](https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage))
+     * * appcache: html5 [application cache](https://developer.mozilla.org/en-US/docs/Web/HTML/Using_the_application_cache)
+     * @example
+     * ```js
+     * const clearCacheOptions = {
+     *     appcache: true,
+     *     cache: true,
+     *     cookies: true,
+     *     localStorage: true
+     * };
+     * fin.System.clearCache(clearCacheOptions).then(() => console.log('Cache cleared')).catch(err => console.log(err));
+     * ```
+     *
+     */
+    clearCache(options) {
+        return this.wire.sendAction('clear-cache', options).then(() => undefined);
+    }
+    /**
+     * Clears all cached data when OpenFin Runtime exits.
+     *
+     * @example
+     * ```js
+     * fin.System.deleteCacheOnExit().then(() => console.log('Deleted Cache')).catch(err => console.log(err));
+     * ```
+     */
+    deleteCacheOnExit() {
+        return this.wire.sendAction('delete-cache-request').then(() => undefined);
+    }
+    /**
+     * Exits the Runtime.
+     *
+     * @example
+     * ```js
+     * fin.System.exit().then(() => console.log('exit')).catch(err => console.log(err));
+     * ```
+     */
+    exit() {
+        return this.wire.sendAction('exit-desktop').then(() => undefined);
+    }
+    /**
+     * Fetches a JSON manifest using the browser process and returns a Javascript object.
+     * @param manifestUrl The URL of the manifest to fetch.
+     *
+     * @example
+     * ```js
+     * const manifest = await fin.System.fetchManifest('https://www.path-to-manifest.com');
+     * console.log(manifest);
+     * ```
+     */
+    async fetchManifest(manifestUrl) {
+        const { payload: { data } } = await this.wire.sendAction('fetch-manifest', { manifestUrl });
+        return data;
+    }
+    /**
+     * Writes any unwritten cookies data to disk.
+     *
+     * @example
+     * ```js
+     * fin.System.flushCookieStore()
+     *     .then(() => console.log('success'))
+     *     .catch(err => console.error(err));
+     * ```
+     */
+    flushCookieStore() {
+        return this.wire.sendAction('flush-cookie-store').then(() => undefined);
+    }
+    /**
+     * Retrieves an array of data (name, ids, bounds) for all application windows.
+     *
+     * @example
+     * ```js
+     * fin.System.getAllWindows().then(wins => console.log(wins)).catch(err => console.log(err));
+     * ```
+     */
+    getAllWindows() {
+        return this.wire.sendAction('get-all-windows').then(({ payload }) => payload.data);
+    }
+    /**
+     * Retrieves an array of data for all applications.
+     *
+     * @example
+     * ```js
+     * fin.System.getAllApplications().then(apps => console.log(apps)).catch(err => console.log(err));
+     * ```
+     */
+    getAllApplications() {
+        return this.wire.sendAction('get-all-applications').then(({ payload }) => payload.data);
+    }
+    /**
+     * Retrieves the command line argument string that started OpenFin Runtime.
+     *
+     * @example
+     * ```js
+     * fin.System.getCommandLineArguments().then(args => console.log(args)).catch(err => console.log(err));
+     * ```
+     */
+    getCommandLineArguments() {
+        return this.wire.sendAction('get-command-line-arguments').then(({ payload }) => payload.data);
+    }
+    /**
+     * Get the current state of the crash reporter.
+     *
+     * @example
+     * ```js
+     * fin.System.getCrashReporterState().then(state => console.log(state)).catch(err => console.log(err));
+     * ```
+     */
+    async getCrashReporterState() {
+        const { payload: { data: { diagnosticMode, isRunning } } } = await this.wire.sendAction('get-crash-reporter-state');
+        console.warn('diagnosticMode property is deprecated. It will be removed in a future version');
+        return {
+            // diagnosticMode will be removed in a future version
+            diagnosticMode,
+            diagnosticsMode: diagnosticMode,
+            isRunning
+        };
+    }
+    /**
+     * Start the crash reporter if not already running.
+     * @param options - configure crash reporter
+     *
+     * @remarks You can optionally specify `diagnosticsMode` to have the logs sent to
+     * OpenFin on runtime close. (NOTE: `diagnosticsMode` will turn on verbose logging and disable the sandbox
+     * for newly launched renderer processes. See https://developers.openfin.co/of-docs/docs/debugging#diagnostics-mode for
+     * more details.)
+     *
+     * @example
+     * ```js
+     * fin.System.startCrashReporter({diagnosticsMode: true}).then(reporter => console.log(reporter)).catch(err => console.log(err));
+     * ```
+     */
+    async startCrashReporter(options) {
+        const opts = options;
+        const newOpts = { ...opts, diagnosticMode: opts.diagnosticsMode || opts.diagnosticMode };
+        const { payload: { data: { diagnosticMode, isRunning } } } = await this.wire.sendAction('start-crash-reporter', newOpts);
+        return {
+            // diagnosticMode will be removed in a future version
+            diagnosticMode,
+            diagnosticsMode: diagnosticMode,
+            isRunning
+        };
+    }
+    /**
+     * Returns a hex encoded hash of the machine id and the currently logged in user name.
+     * This is the recommended way to uniquely identify a user / machine combination.
+     *
+     * @remarks For Windows systems this is a sha256 hash of the machine ID set in the registry key:
+     * `HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Cryptography\MachineGuid` and `USERNAME`.
+     *
+     * For OSX systems, a native-level call is used to get the machine ID.
+     *
+     * @example
+     * ```js
+     * fin.System.getUniqueUserId().then(id => console.log(id)).catch(err => console.log(err));
+     * ```
+     */
+    getUniqueUserId() {
+        return this.wire.sendAction('get-unique-user-id').then(({ payload }) => payload.data);
+    }
+    /**
+     * Retrieves a frame info object for the uuid and name passed in
+     * @param uuid - The UUID of the target.
+     * @param name - The name of the target.
+     *
+     * @remarks The possible types are 'window', 'iframe', 'external connection' or 'unknown'.
+     * @example
+     * ```js
+     * const entityUuid = 'OpenfinPOC';
+     * const entityName = '40c74b5d-ed98-40f7-853f-e3d3c2699175';
+     * fin.System.getEntityInfo(entityUuid, entityName).then(info => console.log(info)).catch(err => console.log(err));
+     *
+     * // example info shape
+     * {
+     *     "uuid": "OpenfinPOC",
+     *     "name": "40c74b5d-ed98-40f7-853f-e3d3c2699175",
+     *     "parent": {
+     *         "uuid": "OpenfinPOC",
+     *         "name": "OpenfinPOC"
+     *     },
+     *     "entityType": "iframe"
+     * }
+     * ```
+     */
+    getEntityInfo(uuid, name) {
+        return this.wire.sendAction('get-entity-info', { uuid, name }).then(({ payload }) => payload.data);
+    }
+    /**
+     * Gets the value of a given environment variable on the computer on which the runtime is installed
+     *
+     * @example
+     * ```js
+     * fin.System.getEnvironmentVariable('HOME').then(env => console.log(env)).catch(err => console.log(err));
+     * ```
+     */
+    getEnvironmentVariable(envName) {
+        return this.wire
+            .sendAction('get-environment-variable', {
+            environmentVariables: envName
+        })
+            .then(({ payload }) => payload.data);
+    }
+    /**
+     * Get currently focused Window.
+     * If a View currently has focus, returns the identity of View's parent Window.
+     * Use {@link Window._Window#getFocusedContent Window.getFocusedContent} to directly access currently focused Window or View.
+     *
+     * @example
+     * ```js
+     * fin.System.getFocusedWindow().then(winInfo => console.log(winInfo)).catch(err => console.log(err));
+     * ```
+     */
+    getFocusedWindow() {
+        return this.wire.sendAction('get-focused-window').then(({ payload }) => payload.data);
+    }
+    /**
+     * Get currently focused content. Returns identity of entity with `entityType`.
+     *
+     * @example
+     * ```js
+     * fin.System.getFocusedContent().then(contentIdentity => console.log(contentIdentity)).catch(err => console.log(err));
+     * ```
+     */
+    getFocusedContent() {
+        return this.wire.sendAction('get-focused-content').then(({ payload }) => payload.data);
+    }
+    /**
+     * Returns information about the given app's certification status
+     *
+     * @example
+     * ```js
+     * const manifestUrl = "http://localhost:1234/app.json"
+     * try {
+     *     const certificationInfo = await fin.System.isAppCertified(manifestUrl);
+     * } catch(err) {
+     *     console.error(err)
+     * }
+     * ```
+     */
+    async isAppCertified(manifestUrl) {
+        const { payload: { data: { certifiedInfo } } } = await this.wire.sendAction('is-app-certified', { manifestUrl });
+        return certifiedInfo;
+    }
+    /**
+     * Returns an array of all the installed runtime versions in an object.
+     *
+     * @example
+     * ```js
+     * fin.System.getInstalledRuntimes().then(runtimes => console.log(runtimes)).catch(err => console.log(err));
+     * ```
+     */
+    // incompatible with standalone node process.
+    getInstalledRuntimes() {
+        return this.wire.sendAction('get-installed-runtimes').then(({ payload }) => payload.data.runtimes);
+    }
+    // incompatible with standalone node process.
+    async getInstalledApps() {
+        const { payload: { data: { installedApps } } } = await this.wire.sendAction('get-installed-apps');
+        return installedApps;
+    }
+    /**
+     * Retrieves the contents of the log with the specified filename.
+     * @param options A object that id defined by the GetLogRequestType interface
+     *
+     * @example
+     * ```js
+     * async function getLog() {
+     *     const logs = await fin.System.getLogList();
+     *     return await fin.System.getLog(logs[0]);
+     * }
+     *
+     * getLog().then(log => console.log(log)).catch(err => console.log(err));
+     * ```
+     */
+    getLog(options) {
+        return this.wire.sendAction('view-log', options).then(({ payload }) => payload.data);
+    }
+    /**
+     * Returns a unique identifier (UUID) provided by the machine.
+     *
+     * @example
+     * ```js
+     * fin.System.getMachineId().then(id => console.log(id)).catch(err => console.log(err));
+     * ```
+     */
+    getMachineId() {
+        return this.wire.sendAction('get-machine-id').then(({ payload }) => payload.data);
+    }
+    /**
+     * Returns the minimum (inclusive) logging level that is currently being written to the log.
+     *
+     * @example
+     * ```js
+     * fin.System.getMinLogLevel().then(level => console.log(level)).catch(err => console.log(err));
+     * ```
+     */
+    getMinLogLevel() {
+        return this.wire.sendAction('get-min-log-level').then(({ payload }) => payload.data);
+    }
+    /**
+     * Retrieves an array containing information for each log file.
+     *
+     * @example
+     * ```js
+     * fin.System.getLogList().then(logList => console.log(logList)).catch(err => console.log(err));
+     * ```
+     */
+    getLogList() {
+        return this.wire.sendAction('list-logs').then(({ payload }) => payload.data);
+    }
+    /**
+     * Retrieves an object that contains data about the monitor setup of the
+     * computer that the runtime is running on.
+     *
+     * @example
+     * ```js
+     * fin.System.getMonitorInfo().then(monitorInfo => console.log(monitorInfo)).catch(err => console.log(err));
+     * ```
+     */
+    getMonitorInfo() {
+        return this.wire.sendAction('get-monitor-info').then(({ payload }) => payload.data);
+    }
+    /**
+     * Returns the mouse in virtual screen coordinates (left, top).
+     *
+     * @example
+     * ```js
+     * fin.System.getMousePosition().then(mousePosition => console.log(mousePosition)).catch(err => console.log(err));
+     * ```
+     */
+    getMousePosition() {
+        return this.wire.sendAction('get-mouse-position').then(({ payload }) => payload.data);
+    }
+    /**
+     * Retrieves an array of all of the runtime processes that are currently
+     * running. Each element in the array is an object containing the uuid
+     * and the name of the application to which the process belongs.
+     * @deprecated Please use our new set of process APIs:
+     * {@link Window._Window#getProcessInfo Window.getProcessInfo}
+     * {@link View.View#getProcessInfo View.getProcessInfo}
+     * {@link Application.Application#getProcessInfo Application.getProcessInfo}
+     * {@link System#getAllProcessInfo System.getAllProcessInfo}
+     *
+     * @example
+     * ```js
+     * fin.System.getProcessList().then(ProcessList => console.log(ProcessList)).catch(err => console.log(err));
+     * ```
+     */
+    getProcessList() {
+        // eslint-disable-next-line no-console
+        console.warn('System.getProcessList has been deprecated. Please consider using our new process APIs: Window.getProcessInfo, View.getProcessInfo, Application.getProcessInfo, System.getAllProcessInfo');
+        return this.wire.sendAction('process-snapshot').then(({ payload }) => payload.data);
+    }
+    /**
+     * Retrieves all process information.
+     *
+     * @remarks This includes the browser process and every process associated to all entities (windows and views).
+     *
+     * @example
+     * ```js
+     * const allProcessInfo = await fin.System.getAllProcessInfo();
+     * ```
+     * @experimental
+     */
+    async getAllProcessInfo() {
+        const { payload: { data } } = await this.wire.sendAction('get-all-process-info', this.identity);
+        return data;
+    }
+    /**
+     * Retrieves the Proxy settings.
+     *
+     * @example
+     * ```js
+     * fin.System.getProxySettings().then(ProxySetting => console.log(ProxySetting)).catch(err => console.log(err));
+     *
+     * //This response has the following shape:
+     * {
+     *     config: {
+     *         proxyAddress: "proxyAddress", //the configured Proxy Address
+     *         proxyPort: 0, //the configured Proxy port
+     *         type: "system" //Proxy Type
+     *     },
+     *     system: {
+     *         autoConfigUrl: "",
+     *         bypass: "",
+     *         enabled: false,
+     *         proxy: ""
+     *     }
+     * }
+     * ```
+     */
+    getProxySettings() {
+        return this.wire.sendAction('get-proxy-settings').then(({ payload }) => payload.data);
+    }
+    /**
+     * Returns information about the running Runtime in an object.
+     *
+     * @example
+     * ```js
+     * fin.System.getRuntimeInfo().then(RuntimeInfo => console.log(RuntimeInfo)).catch(err => console.log(err));
+     * ```
+     */
+    getRuntimeInfo() {
+        return this.wire.sendAction('get-runtime-info').then(({ payload }) => payload.data);
+    }
+    /**
+     * Returns information about the running RVM in an object.
+     *
+     * @example
+     * ```js
+     * fin.System.getRvmInfo().then(RvmInfo => console.log(RvmInfo)).catch(err => console.log(err));
+     * ```
+     */
+    // incompatible with standalone node process.
+    getRvmInfo() {
+        return this.wire.sendAction('get-rvm-info').then(({ payload }) => payload.data);
+    }
+    /**
+     * Retrieves general system information. If you need more detailed information about the
+     * OS and the currently logged in user, use `fin.System.getOSInfo()` instead.
+     *
+     * @example
+     * ```js
+     * fin.System.getHostSpecs().then(specs => console.log(specs)).catch(err => console.log(err));
+     * ```
+     */
+    getHostSpecs() {
+        return this.wire.sendAction('get-host-specs').then(({ payload }) => payload.data);
+    }
+    /**
+     * Retrieves information about the OS and the currently logged in user.
+     *
+     * @example
+     * ```js
+     * fin.System.getOSInfo().then(specs => console.log(specs)).catch(err => console.log(err));
+     * ```
+     */
+    getOSInfo() {
+        return this.wire.sendAction('get-os-info').then(({ payload }) => payload.data);
+    }
+    /**
+     * Runs an executable or batch file. A path to the file must be included in options.
+     * 
 A uuid may be optionally provided. If not provided, OpenFin will create a uuid for the new process.
+     * 
 Note: This method is restricted by default and must be enabled via
+     * API security settings. Also, this api has an enhanced permission set to make it less dangerous. So application owners can only allow to launch the assets owned by the application, the enabled downloaded files or the restricted executables.
+     * @param options A object that is defined in the ExternalProcessRequestType interface
+     *
+     * @remarks If an unused UUID is provided in options, it will be used. If no UUID is provided, OpenFin will assign one.
+     * This api has an enhanced permission set to make it less dangerous. So application owners can only allow to launch the
+     * assets owned by the application, the enabled downloaded files or the restricted executables.
+     *
+     * **Note:** Since _appAssets_ relies on the RVM, which is missing on MAC_OS, 'alias' is not available. Instead provide
+     * the full path e.g. _/Applications/Calculator.app/Contents/MacOS/Calculator_.
+     *
+     * @example
+     * Basic Example:
+     * ```js
+     * fin.System.launchExternalProcess({
+     *     path: 'notepad',
+     *     arguments: '',
+     *     listener: function (result) {
+     *         console.log('the exit code', result.exitCode);
+     *     }
+     * }).then(processIdentity => {
+     *     console.log(processIdentity);
+     * }).catch(error => {
+     *     console.log(error);
+     * });
+     * ```
+     *
+     * Promise resolution:
+     *
+     * ```js
+     * //This response has the following shape:
+     * {
+     *     uuid: "FB3E6E36-0976-4C2B-9A09-FB2E54D2F1BB" // The mapped UUID which identifies the launched process
+     * }
+     * ```
+     *
+     * Listener callback:
+     * ```js
+     * //This response has the following shape:
+     * {
+     *     topic: "exited", // Or "released" on a call to releaseExternalProcess
+     *     uuid: "FB3E6E36-0976-4C2B-9A09-FB2E54D2F1BB", // The mapped UUID which identifies the launched process
+     *     exitCode: 0 // Process exit code
+     * }
+     * ```
+     *
+     * By specifying a lifetime, an external process can live as long the window/application that launched it or
+     * persist after the application exits. The default value is null, which is equivalent to 'persist', meaning
+     * the process lives on after the application exits:
+     *
+     * ```js
+     * fin.System.launchExternalProcess({
+     *     path: 'notepad',
+     *     arguments: '',
+     *     listener: (result) => {
+     *         console.log('the exit code', result.exitCode);
+     *     },
+     *     lifetime: 'window'
+     * }).then(processIdentity => {
+     *     console.log(processIdentity);
+     * }).catch(error => {
+     *     console.log(error);
+     * });
+     * ```
+     *
+     * Note: A process that exits when the window/application exits cannot be released via fin.desktop.System.releaseExternalProcess.
+     *
+     * By specifying a cwd, it will set current working directory when launching an external process:
+     *
+     * ```js
+     * fin.System.launchExternalProcess({
+     *     path: 'cmd.exe',
+     *     cwd: 'c:\\temp',
+     *     arguments: '',
+     *     listener: (result) => {
+     *         console.log('the exit code', result.exitCode);
+     *     }
+     * }).then(processIdentity => {
+     *     console.log(processIdentity);
+     * }).catch(error => {
+     *     console.log(error);
+     * });
+     * ```
+     *
+     * Example using an alias from app.json appAssets property:
+     *
+     * ```json
+     * "appAssets": [
+     *     {
+     *         "src": "exe.zip",
+     *         "alias": "myApp",
+     *         "version": "4.12.8",
+     *         "target": "myApp.exe",
+     *         "args": "a b c d"
+     *     },
+     * ]
+     * ```
+     *
+     * ```js
+     * //  When called, if no arguments are passed then the arguments (if any)
+     * //  are taken from the 'app.json' file, from the  'args' parameter
+     * //  of the 'appAssets' Object with the relevant 'alias'.
+     * fin.System.launchExternalProcess({
+     *     //Additionally note that the executable found in the zip file specified in appAssets
+     *     //will default to the one mentioned by appAssets.target
+     *     //If the the path below refers to a specific path it will override this default
+     *     alias: 'myApp',
+     *     listener: (result) => {
+     *         console.log('the exit code', result.exitCode);
+     *     }
+     * }).then(processIdentity => {
+     *     console.log(processIdentity);
+     * }).catch(error => {
+     *     console.log(error);
+     * });
+     * ```
+     *
+     * Example using an alias but overriding the arguments:
+     *
+     * ```json
+     * "appAssets": [
+     *     {
+     *         "src": "exe.zip",
+     *         "alias": "myApp",
+     *         "version": "4.12.8",
+     *         "target": "myApp.exe",
+     *         "args": "a b c d"
+     *     },
+     * ]
+     * ```
+     *
+     * ```js
+     * //  If 'arguments' is passed as a parameter it takes precedence
+     * //  over any 'args' set in the 'app.json'.
+     * fin.System.launchExternalProcess({
+     *     alias: 'myApp',
+     *     arguments: 'e f g',
+     *     listener: (result) => {
+     *         console.log('the exit code', result.exitCode);
+     *     }
+     * }).then(processIdentity => {
+     *     console.log(processIdentity);
+     * }).catch(error => {
+     *     console.log(error);
+     * });
+     * ```
+     *
+     * It is now possible to optionally perform any combination of the following certificate checks
+     * against an absolute target via `fin.desktop.System.launchExternalProcess()`:
+     *
+     * ```js
+     * "certificate": {
+     *     "serial": "3c a5 ...",                        // A hex string with or without spaces
+     *     "subject": "O=OpenFin INC., L=New York, ...", // An internally tokenized and comma delimited string allowing partial or full checks of the subject fields
+     *     "publickey": "3c a5 ...",                     // A hex string with or without spaces
+     *     "thumbprint": "3c a5 ...",                    // A hex string with or without spaces
+     *     "trusted": true                               // A boolean indicating that the certificate is trusted and not revoked
+     * }
+     * ```
+     *
+     * Providing this information as part of the default configurations for assets in an application's manifest
+     * will be added in a future RVM update:
+     *
+     * ```js
+     * fin.System.launchExternalProcess({
+     *     path: 'C:\\Users\\ExampleUser\\AppData\\Local\\OpenFin\\OpenFinRVM.exe',
+     *     arguments: '--version',
+     *     certificate: {
+     *         trusted: true,
+     *         subject: 'O=OpenFin INC., L=New York, S=NY, C=US',
+     *         thumbprint: '‎3c a5 28 19 83 05 fe 69 88 e6 8f 4b 3a af c5 c5 1b 07 80 5b'
+     *     },
+     *     listener: (result) => {
+     *         console.log('the exit code', result.exitCode);
+     *     }
+     * }).then(processIdentity => {
+     *     console.log(processIdentity);
+     * }).catch(error => {
+     *     console.log(error);
+     * });
+     * ```
+     *
+     * It is possible to launch files that have been downloaded by the user by listening to the window
+     * `file-download-completed` event and using the `fileUuid` provided by the event:
+     *
+     * ```js
+     * const win = fin.Window.getCurrentSync();
+     * win.addListener('file-download-completed', (evt) => {
+     *     if (evt.state === 'completed') {
+     *         fin.System.launchExternalProcess({
+     *             fileUuid: evt.fileUuid,
+     *             arguments: '',
+     *             listener: (result) => {
+     *                 console.log('the exit code', result.exitCode);
+     *             }
+     *         }).then(processIdentity => {
+     *             console.log(processIdentity);
+     *         }).catch(error => {
+     *             console.log(error);
+     *         });
+     *     }
+     * });
+     * ```
+     *
+     * Launching assets specified in the app manifest:
+     *
+     * Sample appAssets section in app.json
+     * ```js
+     *     "appAssets": [
+     *         {
+     *             "src": "http://filesamples.com/exe.zip",
+     *             "alias": "myApp",
+     *             "version": "4.12.8",
+     *             "target": "myApp.exe",
+     *             "args": "a b c d"
+     *         },
+     *         {
+     *             "src": "http://examples.com/exe.zip",
+     *             "alias": "myApp2",
+     *             "version": "5.12.8",
+     *             "target": "myApp2.exe",
+     *             "args": "a b c"
+     *         }
+     *     ]
+     * ```
+     *
+     * This permission allows for launching of all assets specified in the above appAssets section. ("myApp" and "myApp2"):
+     *
+     * ```js
+     *     "permissions": {
+     *        "System": {
+     *            "launchExternalProcess": {
+     *                 "enabled": true,
+     *                 "assets": {
+     *                     "enabled": true
+     *                 }
+     *             }
+     *        }
+     *     }
+     * ```
+     *
+     * This permission allows for launching of _only_ the "myApp" asset in the above appAssets section, as defined in `srcRules`:
+     * ```js
+     *     "permissions": {
+     *        "System": {
+     *            "launchExternalProcess": {
+     *                 "enabled": true,
+     *                 "assets": {
+     *                     "enabled": true
+     *                     "srcRules": [
+     *                         {
+     *                             "match": [
+     *                                 "*://filesamples.com/*"
+     *                             ],
+     *                             "behavior": "allow"
+     *                         },
+     *                         {
+     *                             "match": [
+     *                                 ""
+     *                             ],
+     *                             "behavior": "block"
+     *                         }
+     *                     ]
+     *                 }
+     *             }
+     *        }
+     *     }
+     * ```
+     *
+     * Launching downloaded files:
+     * ```js
+     *     "permissions": {
+     *        "System": {
+     *            "launchExternalProcess": {
+     *                 "enabled": true,
+     *                 "downloads": {
+     *                     "enabled": true
+     *                 }
+     *             }
+     *        }
+     *     }
+     * ```
+     *
+     * This permission allows to launch all the executables:
+     * ```js
+     *     "permissions": {
+     *        "System": {
+     *            "launchExternalProcess": {
+     *                 "enabled": true,
+     *                 "executables": {
+     *                     "enabled": true
+     *                 }
+     *             }
+     *        }
+     *     }
+     * ```
+     *
+     *
+     * This permission only allows launching of executables whose file paths match the corresponding `pathRules`:
+     * ```js
+     *     "permissions": {
+     *        "System": {
+     *            "launchExternalProcess": {
+     *                 "enabled": true,
+     *                 "executables": {
+     *                     "enabled": true
+     *                     "pathRules": [
+     *                         {
+     *                             "match": [
+     *                                 "/Windows/System32/*.exe"
+     *                             ],
+     *                             "behavior": "allow"
+     *                         },
+     *                         {
+     *                             "match": [
+     *                                 "*.exe"
+     *                             ],
+     *                             "behavior": "block"
+     *                         }
+     *                     ]
+     *                 }
+     *             }
+     *        }
+     *     }
+     * ```
+     */
+    launchExternalProcess(options) {
+        return this.sendExternalProcessRequest('launch-external-process', options);
+    }
+    /**
+     * Monitors a running process. A pid for the process must be included in options.
+     * 
 A uuid may be optionally provided. If not provided, OpenFin will create a uuid for the new process.
+     *
+     * @remarks If an unused uuid is provided in options, it will be used. If no uuid is provided, OpefinFin will assign a uuid.
+     * @example
+     * ```js
+     * fin.System.monitorExternalProcess({
+     *     pid: 10208,
+     *     uuid: 'my-external-process', // optional
+     *     listener: function (result) {
+     *         console.log('the exit code', result.exitCode);
+     *     }
+     * }).then(processIdentity => console.log(processIdentity)).catch(err => console.log(err));
+     * ```
+     */
+    monitorExternalProcess(options) {
+        return this.sendExternalProcessRequest('monitor-external-process', options);
+    }
+    /**
+     * Writes the passed message into both the log file and the console.
+     * @param level The log level for the entry. Can be either "info", "warning" or "error"
+     * @param message The log message text
+     *
+     * @example
+     * ```js
+     * fin.System.log("info", "An example log message").then(() => console.log('Log info message')).catch(err => console.log(err));
+     * ```
+     */
+    log(level, message) {
+        return this.wire.sendAction('write-to-log', { level, message }).then(() => undefined);
+    }
+    /**
+     * Opens the passed URL in the default web browser.
+     *
+     * @remarks It only supports http(s) and fin(s) protocols by default.
+     * In order to use other custom protocols, they have to be enabled via
+     * [API security settings](https://developers.openfin.co/docs/api-security).
+     * File protocol and file path are not supported.
+     * @param url The URL to open
+     *
+     * @example
+     * ```js
+     * fin.System.openUrlWithBrowser('https://cdn.openfin.co/docs/javascript/stable/tutorial-System.openUrlWithBrowser.html')
+     * .then(() => console.log('Opened URL'))
+     * .catch(err => console.log(err));
+     * ```
+     *
+     * Example of permission definition to enable non-default protocols:
+     *
+     * Note: permission definition should be specified in an app manifest file if there is no DOS settings.
+     * Otherwise it has to be specified in both DOS and app manifest files.
+     *
+     * ```js
+     *     "permissions": {
+     *        "System": {
+     *            "openUrlWithBrowser": {
+     *                 "enabled": true,
+     *                 "protocols": [ "msteams", "slack"]
+     *             }
+     *        }
+     *     }
+     * ```
+     */
+    openUrlWithBrowser(url) {
+        return this.wire.sendAction('open-url-with-browser', { url }).then(() => undefined);
+    }
+    /**
+     * Creates a new registry entry under the HKCU root Windows registry key if the given custom protocol name doesn't exist or
+     * overwrites the existing registry entry if the given custom protocol name already exists.
+     *
+     * Note: This method is restricted by default and must be enabled via
+     * {@link https://developers.openfin.co/docs/api-security API security settings}. It requires RVM 12 or higher version.
+     *
+     *
+     * @remarks These protocols are reserved and cannot be registered:
+     * - fin
+     * - fins
+     * - openfin
+     * - URI Schemes registered with {@link https://en.wikipedia.org/wiki/List_of_URI_schemes#Official_IANA-registered_schemes IANA}
+     *
+     * @throws if a given custom protocol failed to be registered.
+     * @throws if a manifest URL contains the '%1' string.
+     * @throws if a manifest URL contains a query string parameter which name equals to the Protocol Launch Request Parameter Name.
+     * @throws if the full length of the command string that is to be written to the registry exceeds 2048 bytes.
+     *
+     * @example
+     * ```js
+     * fin.System.registerCustomProtocol({protocolName:'protocol1'}).then(console.log).catch(console.error);
+     * ```
+     */
+    async registerCustomProtocol(options) {
+        if (typeof options !== 'object') {
+            throw new Error('Must provide an object with a `protocolName` property having a string value.');
+        }
+        await this.wire.sendAction('register-custom-protocol', options);
+    }
+    /**
+     * Removes the registry entry for a given custom protocol.
+     *
+     * Note: This method is restricted by default and must be enabled via
+     * {@link https://developers.openfin.co/docs/api-security API security settings}. It requires RVM 12 or higher version.
+     *
+     *
+     * @remarks These protocols are reserved and cannot be unregistered:
+     * - fin
+     * - fins
+     * - openfin
+     * - URI Schemes registered with {@link https://en.wikipedia.org/wiki/List_of_URI_schemes#Official_IANA-registered_schemes IANA}
+     *
+     * @throws if a protocol entry failed to be removed in registry.
+     *
+     * @example
+     * ```js
+     * await fin.System.unregisterCustomProtocol('protocol1');
+     * ```
+     */
+    async unregisterCustomProtocol(protocolName) {
+        await this.wire.sendAction('unregister-custom-protocol', { protocolName });
+    }
+    /**
+     * Retrieves the registration state for a given custom protocol.
+     *
+     * Note: This method is restricted by default and must be enabled via
+     * {@link https://developers.openfin.co/docs/api-security API security settings}. It requires RVM 12 or higher version.
+     *
+     * @remarks These protocols are reserved and cannot get states for them:
+     * - fin
+     * - fins
+     * - openfin
+     * - URI Schemes registered with {@link https://en.wikipedia.org/wiki/List_of_URI_schemes#Official_IANA-registered_schemes IANA}
+     *
+     *
+     * @example
+     * ```js
+     * const protocolState = await fin.System.getCustomProtocolState('protocol1');
+     */
+    async getCustomProtocolState(protocolName) {
+        return this.wire.sendAction('get-custom-protocol-state', { protocolName }).then(({ payload }) => payload.data);
+    }
+    /**
+     * Removes the process entry for the passed UUID obtained from a prior call
+     * of fin.System.launchExternalProcess().
+     * @param uuid The UUID for a process obtained from a prior call to fin.desktop.System.launchExternalProcess()
+     *
+     * @example
+     * ```js
+     * fin.System.launchExternalProcess({
+     *     path: "notepad",
+     *     listener: function (result) {
+     *         console.log("The exit code", result.exitCode);
+     *     }
+     * })
+     * .then(identity => fin.System.releaseExternalProcess(identity.uuid))
+     * .then(() => console.log('Process has been unmapped!'))
+     * .catch(err => console.log(err));
+     * ```
+     */
+    releaseExternalProcess(uuid) {
+        return this.wire.sendAction('release-external-process', { uuid }).then(() => undefined);
+    }
+    /**
+     * Shows the Chromium Developer Tools for the specified window
+     * @param identity This is a object that is defined by the Identity interface
+     *
+     * @tutorial System.showDeveloperTools
+     */
+    showDeveloperTools(identity) {
+        return this.wire.sendAction('show-developer-tools', identity).then(() => undefined);
+    }
+    /**
+     * Attempt to close an external process. The process will be terminated if it
+     * has not closed after the elapsed timeout in milliseconds.
+     *
+     * Note: This method is restricted by default and must be enabled via
+     * API security settings.
+     * @param options A object defined in the TerminateExternalRequestType interface
+     *
+     * @example
+     * ```js
+     * fin.System.launchExternalProcess({
+     *     path: "notepad",
+     *     listener: function (result) {
+     *         console.log("The exit code", result.exitCode);
+     *     }
+     * })
+     * .then(identity => fin.System.terminateExternalProcess({uuid: identity.uuid, timeout:2000, killTree: false}))
+     * .then(() => console.log('Terminate the process'))
+     * .catch(err => console.log(err));
+     * ```
+     */
+    terminateExternalProcess(options) {
+        return this.wire.sendAction('terminate-external-process', options).then(() => undefined);
+    }
+    /**
+     * Update the OpenFin Runtime Proxy settings.
+     * @param options A config object defined in the ProxyConfig interface
+     *
+     * @example
+     * ```js
+     * fin.System.updateProxySettings({proxyAddress:'127.0.0.1', proxyPort:8080, type:'http'})
+     * .then(() => console.log('Update proxy successfully'))
+     * .catch(err => console.error(err));
+     * ```
+     */
+    updateProxySettings(options) {
+        return this.wire.sendAction('update-proxy', options).then(() => undefined);
+    }
+    /**
+     * Downloads the given application asset.
+     *
+     * Note: This method is restricted by default and must be enabled via
+     * API security settings.
+     * @param appAsset App asset object
+     *
+     * @example
+     * ```js
+     * async function downloadAsset() {
+     *     const appAsset = {
+     *         src: `${ location.origin }/assets.zip`,
+     *         alias: 'dirApp',
+     *         version: '1.23.24',
+     *         target: 'assets/run.bat'
+     *     };
+     *
+     *     return fin.System.downloadAsset(appAsset, (progress => {
+     *     //Print progress as we download the asset.
+     *         const downloadedPercent = Math.floor((progress.downloadedBytes / progress.totalBytes) * 100);
+     *         console.log(`Downloaded ${downloadedPercent}%`);
+     *     }));
+     * }
+     *
+     * downloadAsset()
+     * .then(() => console.log('Success'))
+     * .catch(err => console.error(err));
+     *
+     * ```
+     */
+    // incompatible with standalone node process.
+    async downloadAsset(appAsset, progressListener) {
+        // eslint-disable-next-line @typescript-eslint/explicit-function-return-type, @typescript-eslint/no-empty-function
+        const noop = () => { };
+        let resolve = noop;
+        let reject = noop;
+        const downloadCompletePromise = new Promise((y, n) => {
+            resolve = y;
+            reject = n;
+        });
+        // node.js environment not supported
+        if (this.wire.environment.type !== 'openfin') {
+            throw new transport_errors_1$1.NotSupportedError('downloadAsset only supported in an OpenFin Render process');
+        }
+        const callSite = transport_errors_1$1.RuntimeError.getCallSite();
+        const downloadId = this.wire.environment.getNextMessageId().toString();
+        const dlProgressKey = `asset-download-progress-${downloadId}`;
+        const dlErrorKey = `asset-download-error-${downloadId}`;
+        const dlCompleteKey = `asset-download-complete-${downloadId}`;
+        const dlProgress = (progress) => {
+            const p = {
+                downloadedBytes: progress.downloadedBytes,
+                totalBytes: progress.totalBytes
+            };
+            progressListener(p);
+        };
+        const cleanListeners = () => {
+            // TODO: fix internal types
+            // @ts-expect-error
+            this.removeListener(dlProgressKey, dlProgress);
+        };
+        const dlError = (payload) => {
+            cleanListeners();
+            const { reason, err: error } = payload;
+            reject(new transport_errors_1$1.RuntimeError({ reason, error }, callSite));
+        };
+        const dlComplete = () => {
+            cleanListeners();
+            resolve();
+        };
+        await Promise.all([
+            // TODO: fix internal types
+            // @ts-expect-error
+            this.on(dlProgressKey, dlProgress),
+            // TODO: fix internal types
+            // @ts-expect-error
+            this.once(dlErrorKey, dlError),
+            // TODO: fix internal types
+            // @ts-expect-error
+            this.once(dlCompleteKey, dlComplete)
+        ]);
+        const downloadOptions = Object.assign(appAsset, { downloadId });
+        await this.wire.sendAction('download-asset', downloadOptions).catch((err) => {
+            cleanListeners();
+            throw err;
+        });
+        return downloadCompletePromise;
+    }
+    /**
+     * Downloads a version of the runtime.
+     * @param options - Download options.
+     * @param progressListener - called as the runtime is downloaded with progress information.
+     *
+     * @remarks Only supported in an OpenFin Render process.
+     *
+     * @example
+     * ```js
+     * var downloadOptions = {
+     *     //Specific version number required, if given a release channel the call will produce an error.
+     *     version: '9.61.30.1'
+     * };
+     *
+     * function onProgress(progress) {
+     *     console.log(`${Math.floor((progress.downloadedBytes / progress.totalBytes) * 100)}%`);
+     * }
+     *
+     * fin.System.downloadRuntime(downloadOptions, onProgress).then(() => {
+     *     console.log('Download complete');
+     * }).catch(err =>    {
+     *     console.log(`Download Failed, we could retry: ${err.message}`);
+     *     console.log(err);
+     * });
+     * ```
+     */
+    downloadRuntime(options, progressListener) {
+        const callsites = transport_errors_1$1.RuntimeError.getCallSite();
+        return new Promise((resolve, reject) => {
+            // node.js environment not supported
+            if (this.wire.environment.type !== 'openfin') {
+                reject(new transport_errors_1$1.NotSupportedError('downloadRuntime only supported in an OpenFin Render process'));
+                return;
+            }
+            const downloadId = this.wire.environment.getNextMessageId().toString();
+            const dlProgressKey = `runtime-download-progress-${downloadId}`;
+            const dlErrorKey = `runtime-download-error-${downloadId}`;
+            const dlCompleteKey = `runtime-download-complete-${downloadId}`;
+            const dlProgress = (progress) => {
+                const p = {
+                    downloadedBytes: progress.downloadedBytes,
+                    totalBytes: progress.totalBytes
+                };
+                progressListener(p);
+            };
+            const cleanListeners = () => {
+                // TODO: fix internal types
+                // @ts-expect-error
+                this.removeListener(dlProgressKey, dlProgress);
+            };
+            const dlError = (payload) => {
+                cleanListeners();
+                const { reason, err: error } = payload;
+                reject(new transport_errors_1$1.RuntimeError({ reason, error }, callsites));
+            };
+            const dlComplete = () => {
+                cleanListeners();
+                resolve();
+            };
+            // TODO: fix internal types
+            // @ts-expect-error
+            this.on(dlProgressKey, dlProgress);
+            // TODO: fix internal types
+            // @ts-expect-error
+            this.once(dlErrorKey, dlError);
+            // TODO: fix internal types
+            // @ts-expect-error
+            this.once(dlCompleteKey, dlComplete);
+            const downloadOptions = Object.assign(options, { downloadId });
+            this.wire.sendAction('download-runtime', downloadOptions).catch((err) => {
+                cleanListeners();
+                reject(err);
+            });
+        });
+    }
+    /**
+     * Download preload scripts from given URLs
+     * @param scripts - URLs of preload scripts.
+     *
+     * @example
+     * ```js
+     * const scripts = [
+     *     { url: 'http://.../preload.js' },
+     *     { url: 'http://.../preload2.js' }
+     * ];
+     *
+     * fin.System.downloadPreloadScripts(scripts).then(results => {
+     *     results.forEach(({url, success, error}) => {
+     *         console.log(`URL: ${url}`);
+     *         console.log(`Success: ${success}`);
+     *         if (error) {
+     *             console.log(`Error: ${error}`);
+     *         }
+     *     });
+     * });
+     * ```
+     */
+    downloadPreloadScripts(scripts) {
+        return this.wire.sendAction('download-preload-scripts', { scripts }).then(({ payload }) => payload.data);
+    }
+    /**
+     * Retrieves an array of data (name, ids, bounds) for all application windows.
+     *
+     * @example
+     * ```js
+     * fin.System.getAllExternalApplications()
+     * .then(externalApps => console.log('Total external apps: ' + externalApps.length))
+     * .catch(err => console.log(err));
+     * ```
+     */
+    getAllExternalApplications() {
+        return this.wire.sendAction('get-all-external-applications').then(({ payload }) => payload.data);
+    }
+    /**
+     * Retrieves app asset information.
+     * @param options
+     *
+     * @example
+     * ```js
+     * fin.System.getAppAssetInfo({alias:'procexp'}).then(assetInfo => console.log(assetInfo)).catch(err => console.log(err));
+     * ```
+     */
+    getAppAssetInfo(options) {
+        return this.wire.sendAction('get-app-asset-info', options).then(({ payload }) => payload.data);
+    }
+    /**
+     * Get additional info of cookies.
+     *
+     * @example
+     * ```js
+     * fin.System.getCookies({name: 'myCookie'}).then(cookies => console.log(cookies)).catch(err => console.log(err));
+     * ```
+     */
+    getCookies(options) {
+        const url = this.wire.environment.getUrl();
+        const newOptions = Object.assign(options, { url });
+        return this.wire.sendAction('get-cookies', newOptions).then(({ payload }) => payload.data);
+    }
+    /**
+     * Set the minimum log level above which logs will be written to the OpenFin log
+     * @param The minimum level (inclusive) above which all calls to log will be written
+     *
+     * @example
+     * ```js
+     * fin.System.setMinLogLevel("verbose").then(() => console.log("log level is set to verbose")).catch(err => console.log(err));
+     * ```
+     */
+    setMinLogLevel(level) {
+        return this.wire.sendAction('set-min-log-level', { level }).then(() => undefined);
+    }
+    /**
+     * Retrieves the UUID of the computer on which the runtime is installed
+     * @param uuid The uuid of the running application
+     *
+     * @example
+     * ```js
+     * fin.System.resolveUuid('OpenfinPOC').then(entity => console.log(entity)).catch(err => console.log(err));
+     * ```
+     */
+    resolveUuid(uuid) {
+        return this.wire
+            .sendAction('resolve-uuid', {
+            entityKey: uuid
+        })
+            .then(({ payload }) => payload.data);
+    }
+    /**
+     * Retrieves an array of data for all external applications
+     * @param requestingIdentity This object is described in the Identity typedef
+     * @param data Any data type to pass to the method
+     *
+     * @ignore
+     */
+    executeOnRemote(requestingIdentity, data) {
+        data.requestingIdentity = requestingIdentity;
+        return this.wire.ferryAction(data);
+    }
+    /**
+     * Reads the specifed value from the registry.
+     * @remarks This method is restricted by default and must be enabled via
+     * [API security settings](https://developers.openfin.co/docs/api-security).
+     * @param rootKey - The registry root key.
+     * @param subkey - The registry key.
+     * @param value - The registry value name.
+     *
+     * @example
+     * ```js
+     * fin.System.readRegistryValue("HKEY_LOCAL_MACHINE", "HARDWARE\\DESCRIPTION\\System", "BootArchitecture").then(val => console.log(val)).catch(err => console.log(err));
+     * ```
+     *
+     * See {@link https://msdn.microsoft.com/en-us/library/windows/desktop/ms681382(v=vs.85).aspx here} for Window's error code definitions.
+     *
+     * Example payloads of different registry types:
+     *
+     * See list of types {@link https://msdn.microsoft.com/en-us/library/windows/desktop/ms724884(v=vs.85).aspx here}.
+     *
+     * ```js
+     * // REG_DWORD
+     * {
+     *     data: 1,
+     *     rootKey: "HKEY_LOCAL_MACHINE",
+     *     subkey: "Foo\Bar",
+     *     type: "REG_DWORD",
+     *     value: "Baz"
+     * }
+     *
+     * // REG_QWORD
+     * {
+     *     data: 13108146671334112,
+     *     rootKey: "HKEY_LOCAL_MACHINE",
+     *     subkey: "Foo\Bar",
+     *     type: "REG_QWORD",
+     *     value: "Baz"
+     * }
+     *
+     * // REG_SZ
+     * {
+     *     data: "FooBarBaz",
+     *     rootKey: "HKEY_LOCAL_MACHINE",
+     *     subkey: "Foo\Bar",
+     *     type: "REG_SZ",
+     *     value: "Baz"
+     * }
+     *
+     * // REG_EXPAND_SZ
+     * {
+     *     data: "C:\User\JohnDoe\AppData\Local",
+     *     rootKey: "HKEY_CURRENT_USER",
+     *     subkey: "Foo\Bar",
+     *     type: "REG_EXPAND_SZ",
+     *     value: "Baz"
+     * }
+     *
+     * // REG_MULTI_SZ
+     * {
+     *     data: [
+     *         "Foo",
+     *         "Bar",
+     *         "Baz"
+     *     ],
+     *     rootKey: "HKEY_CURRENT_USER",
+     *     subkey: "Foo\Bar",
+     *     type: "REG_MULTI_SZ",
+     *     value: "Baz"
+     * }
+     *
+     * // REG_BINARY
+     * {
+     *     data: {
+     *         data: [
+     *             255,
+     *             255,
+     *             0,
+     *             43,
+     *             55,
+     *             0,
+     *             0,
+     *             255,
+     *             255
+     *         ],
+     *         type: "Buffer"
+     *     },
+     *     rootKey: "HKEY_CURRENT_USER",
+     *     subkey: "Foo\Bar",
+     *     type: "REG_BINARY",
+     *     value: "Baz"
+     * }
+     * ```
+     */
+    readRegistryValue(rootKey, subkey, value) {
+        return this.wire
+            .sendAction('read-registry-value', {
+            rootKey,
+            subkey,
+            value
+        })
+            .then(({ payload }) => payload.data);
+    }
+    /**
+     * This function call will register a unique id and produce a token.
+     * The token can be used to broker an external connection.
+     * @param uuid - A UUID for the remote connection.
+     *
+     * @example
+     * ```js
+     * fin.System.registerExternalConnection("remote-connection-uuid").then(conn => console.log(conn)).catch(err => console.log(err));
+     *
+     *
+     * // object comes back with
+     * //     token: "0489EAC5-6404-4F0D-993B-92BB8EAB445D", // this will be unique each time
+     * //     uuid: "remote-connection-uuid"
+     *
+     * ```
+     */
+    registerExternalConnection(uuid) {
+        return this.wire.sendAction('register-external-connection', { uuid }).then(({ payload }) => payload.data);
+    }
+    /**
+     * Returns the json blob found in the [desktop owner settings](https://openfin.co/documentation/desktop-owner-settings/)
+     * for the specified service.
+     * @param serviceIdentifier An object containing a name key that identifies the service.
+     *
+     * @remarks More information about desktop services can be found [here](https://developers.openfin.co/docs/desktop-services).
+     * This call will reject if the desktop owner settings file is not present, not correctly formatted, or if the service requested is not configured or configured incorrectly.
+     *
+     * @example
+     * ```js
+     * // Here we are using the [layouts](https://github.com/HadoukenIO/layouts-service) service.
+     * fin.System.getServiceConfiguration({name:'layouts'}).then(console.log).catch(console.error);
+     * ```
+     */
+    async getServiceConfiguration(serviceIdentifier) {
+        if (typeof serviceIdentifier.name !== 'string') {
+            throw new Error('Must provide an object with a `name` property having a string value');
+        }
+        const { name } = serviceIdentifier;
+        return this.wire.sendAction('get-service-configuration', { name }).then(({ payload }) => payload.data);
+    }
+    async getSystemAppConfig(name) {
+        if (typeof name !== 'string') {
+            throw new Error('Must provide a string value for name of system app');
+        }
+        return this.wire.sendAction('get-system-app-configuration', { name }).then(({ payload }) => payload.data);
+    }
+    /**
+     * Registers a system shutdown handler so user can do some cleanup before system is shutting down.
+     * @remarks Once system shutdown starts, you are unable to cancel it.
+     * @param handler system shutdown handler
+     *
+     * @example
+     * ```js
+     * fin.System.registerShutdownHandler((shutdownEvent) => {
+     *         // save state or cleanup
+     *         console.log('do some cleanup before shutdown');
+     *         // Notify app is ready for termination.
+     *         shutdownEvent.proceed();
+     * })
+     * .then(() => console.log('Shutdown handler registered!'))
+     * .catch(err => console.log(err));
+     * ```
+     * @experimental
+     */
+    async registerShutdownHandler(handler) {
+        this.wire.sendAction('system-register-shutdown-handler').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const SystemShutdownEventName = 'system-shutdown';
+        const SystemShutdownHandledEventName = 'system-shutdown-handled';
+        const { uuid, name } = this.wire.me;
+        const shutdownHandler = (payload) => {
+            const proceed = () => {
+                // notify core that the app is ready for shutdown
+                this.wire.environment.raiseEvent(`application/${SystemShutdownHandledEventName}`, {
+                    uuid,
+                    name,
+                    topic: 'application'
+                });
+            };
+            handler({ proceed });
+        };
+        this.on(SystemShutdownEventName, shutdownHandler);
+    }
+    /**
+     * Signals the RVM to perform a health check and returns the results as json.
+     *
+     * @remarks Requires RVM 5.5+
+     *
+     * @example
+     * ```js
+     * try {
+     *     const results = await fin.System.runRvmHealthCheck();
+     *     console.log(results);
+     * } catch(e) {
+     *      console.error(e);
+     * }
+     * ```
+     */
+    runRvmHealthCheck() {
+        return this.wire.sendAction('run-rvm-health-check').then(({ payload }) => payload.data);
+    }
+    /**
+     * Launch application using a manifest URL/path. It differs from Application.startFromManifest in that this API can accept a manifest using the fin protocol.
+     * @param manifestUrl - The manifest's URL or path.
+     * @param opts - Parameters that the RVM will use.
+     *
+     * @experimental
+     * @remarks Supports protocols http/s and fin/s, and also a local path.
+     *
+     * Note: This API is Windows only.
+     *
+     * @example
+     *
+     * This API can handle most manifest types. Some examples below.
+     *
+     * Traditional:
+     * ```js
+     * const manifest = await fin.System.launchManifest(
+     *   'https://demoappdirectory.openf.in/desktop/config/apps/OpenFin/HelloOpenFin/app.json');
+     * console.log(manifest);
+     * ```
+     *
+     * Platform:
+     * ```js
+     * const manifest = await fin.System.launchManifest('https://openfin.github.io/platform-api-project-seed/public.json');
+     * console.log(manifest);
+     * ```
+     *
+     * Launching traditional manifest into a platform:
+     * ```js
+     * const manifest = await fin.System.launchManifest(
+     *   'https://openfin.github.io/platform-api-project-seed/public.json?\
+     *   $$appManifestUrl=https://demoappdirectory.openf.in/desktop/config/\
+     *   apps/OpenFin/HelloOpenFin/app.json');
+     * console.log(manifest);
+     * ```
+     *
+     * Launching with RVM options:
+     * ```js
+     * const manifest = await fin.System.launchManifest('https://openfin.github.io/platform-api-project-seed/public.json',
+     *     { noUi: true, userAppConfigArgs: { abc: '123', xyz: '789' } });
+     * console.log(manifest);
+     * ```
+     *
+     * Local Path:
+     * ```js
+     * const manifest =  await fin.System.launchManifest('file://c:\\path\\to\\manifest\\file.json');
+     * console.log(manifest);
+     * ```
+     *
+     * Launching with RVM 'subscribe' option:
+     *
+     * This option allows users to subscribe to app version resolver events when
+     * calling launchManifest with fallbackManifests specified.
+     *
+     * ```js
+     * fin.System.launchManifest('fins://system-apps/notifications/app.json', { subscribe: (launch) => {
+     * 		launch.on('app-version-progress', (progress) => {
+     * 			console.log("Trying manifest " + progress.manifest)
+     * 		});
+     *
+     * 		launch.on('runtime-status', (status) => {
+     * 			console.log("Runtime status: " + JSON.stringify(status));
+     * 		});
+     *
+     * 		// RVM has successfully found the target runtime version
+     * 		launch.on('app-version-complete', (complete) => {
+     * 			console.log("Parent app " + complete.srcManifest + " resolved to " + complete.manifest);
+     * 			launch.removeAllListeners();
+     * 		});
+     *
+     * 		// RVM failed to find an available runtime version
+     * 		launch.on('app-version-error', (error) => {
+     * 			console.log("Failed to resolve " + error.srcManifest + " from the fallbackManifests");
+     * 			launch.removeAllListeners();
+     * 		});
+     * 	}
+     * });
+     * ```
+     */
+    async launchManifest(manifestUrl, opts = {}) {
+        const { subscribe, ..._sendOpts } = opts;
+        const sendOpts = _sendOpts;
+        if (subscribe) {
+            const launchEmitter = new events_1$6.EventEmitter();
+            subscribe(launchEmitter);
+            const AppVersionProgressEventName = 'app-version-progress';
+            const RuntimeStatusEventName = 'runtime-status';
+            const AppVersionCompleteEventName = 'app-version-complete';
+            const AppVersionErrorEventName = 'app-version-error';
+            // add id to avoid multiple api calls getting duplicated events
+            const id = this.wire.environment.getNextMessageId().toString();
+            sendOpts.appVersionId = id;
+            const supportedEvents = [
+                AppVersionCompleteEventName,
+                AppVersionProgressEventName,
+                RuntimeStatusEventName,
+                AppVersionErrorEventName
+            ];
+            const cleanEventPayload = (payload) => {
+                // We need to do type castings below to make sure the return type is correct.
+                const { appVersionId, topic, type: typeWithId, ...rest } = payload;
+                const type = supportedEvents.find((x) => typeWithId.includes(x));
+                return {
+                    ...rest,
+                    type
+                };
+            };
+            const appVersionListener = (payload) => {
+                const cleanPayload = cleanEventPayload(payload);
+                launchEmitter.emit(cleanPayload.type, cleanPayload);
+            };
+            const removeAllListeners = () => {
+                this.removeListener(`${AppVersionProgressEventName}.${id}`, appVersionListener);
+                this.removeListener(`${RuntimeStatusEventName}.${id}`, appVersionListener);
+                this.removeListener(`${AppVersionCompleteEventName}.${id}`, appVersionListener);
+                this.removeListener(`${AppVersionErrorEventName}.${id}`, appVersionListener);
+                this.removeListener(`${AppVersionCompleteEventName}.${id}`, removeAllListeners);
+                this.removeListener(`${AppVersionErrorEventName}.${id}`, removeAllListeners);
+            };
+            await Promise.all([
+                this.on(`${AppVersionProgressEventName}.${id}`, appVersionListener),
+                this.on(`${RuntimeStatusEventName}.${id}`, appVersionListener),
+                this.once(`${AppVersionCompleteEventName}.${id}`, appVersionListener),
+                this.once(`${AppVersionErrorEventName}.${id}`, appVersionListener),
+                this.once(`${AppVersionCompleteEventName}.${id}`, removeAllListeners),
+                this.once(`${AppVersionErrorEventName}.${id}`, removeAllListeners)
+            ]);
+        }
+        const response = await this.wire.sendAction('launch-manifest', {
+            manifestUrl,
+            opts: sendOpts
+        });
+        return response.payload.data.manifest;
+    }
+    /**
+     * Query permission of a secured api in current context.
+     *
+     * @param apiName - The full name of a secured API.
+     *
+     * @remarks If a function has a structured permission value, the value of `granted` will reflect the `enabled` key
+     * of the call's permissions literal.  In this case, *permission may still be denied to a call* pending arguments or other
+     * runtime state.  This is indicated with `state: unavailable`.
+     *
+     * @example
+     * ```js
+     * fin.System.queryPermissionForCurrentContext('System.launchExternalProcess').then(result => console.log(result)).catch(err => console.log(err));
+     *
+     * //This response has the following shape:
+     * {
+     *    permission: 'System.launchExternalProcess', // api full name
+     *    state: 'granted', // state of permission
+     *    granted: true
+     * }
+     * ```
+     */
+    async queryPermissionForCurrentContext(apiName) {
+        const identity = { uuid: this.wire.me.uuid, name: this.wire.me.name };
+        const response = await this.wire.sendAction('query-permission-for-current-context', {
+            apiName,
+            identity
+        });
+        return response.payload.data;
+    }
+    // Not documenting, internal use only.
+    async enableNativeWindowIntegrationProvider(permissions) {
+        const { payload } = await this.wire.sendAction('enable-native-window-integration-provider', { permissions });
+        return payload.data;
+    }
+    /**
+     * (Internal) Register the usage of a component with a platform
+     * @param options - Object with data and type
+     *
+     * @example
+     * ```js
+     * async function registerUsage() {
+     *     const app = await fin.System.getCurrent();
+     *     return await fin.System.registerUsage({
+     *         type: 'workspace-licensing',
+     *         // example values for the following data object
+     *         data: {
+     *             apiVersion: '1.0',
+     *             componentName: 'home',
+     *             componentVersion: '1.0',
+     *             allowed: true,
+     *             rejectionCode: ''
+     *         }
+     *     });
+     * }
+     *
+     * registerUsage().then(() => console.log('Successfully registered component application')).catch(err => console.log(err));
+     * ```
+     */
+    async registerUsage({ data, type }) {
+        await this.wire.sendAction('register-usage', { data, type });
+    }
+    /**
+     * Returns an array with all printers of the caller and not all the printers on the desktop.
+     *
+     * @example
+     * ```js
+     * fin.System.getPrinters()
+     *     .then((printers) => {
+     *         printers.forEach((printer) => {
+     *             if (printer.isDefault) {
+     *                 console.log(printer);
+     *             }
+     *         });
+     *     })
+     *     .catch((err) => {
+     *         console.log(err);
+     *     });
+     * ```
+     */
+    async getPrinters() {
+        const { payload } = await this.wire.sendAction('system-get-printers');
+        return payload.data;
+    }
+    /**
+     * Updates Process Logging values: periodic interval and outlier detection entries and interval.
+     * @param options Process Logging updatable options.
+     *
+     * @remarks When enabling verbose mode, additional process information is logged to the debug.log:
+     *
+     * 1. Periodically process usage (memory, cpu, etc) will be logged for each PID along with the windows, views and
+     * iframes that belong to them. The default is every 30 seconds. Updatable by passing the interval option.
+     * 2. When Windows and Views are created or navigated the PID they belong to and their options will be logged.
+     * 3. When Windows and Views are destroyed their last known process usage will be logged.
+     * 4. Whenever an outlier memory usage is detected it will be logged. By default, on an interval of 5 seconds we will
+     * collect process usage for all PIDs and when 144 such entries are collected, we will start analyzing the data for any
+     * possible outliers in the following entries. The interval and maximum number of entries stored in the running buffer
+     * can be updatable by passing the outlierDetection.interval and outlierDetection.entries options.
+     *
+     * @example
+     *
+     * ```js
+     * await fin.System.updateProcessLoggingOptions({
+     *     interval: 10,
+     *     outlierDetection: {
+     *         interval: 15,
+     *         entries: 200
+     *     }
+     * });
+     * ```
+     */
+    async updateProcessLoggingOptions(options) {
+        await this.wire.sendAction('system-update-process-logging-options', { options });
+    }
+    /**
+     * Returns domain settings for the current application.
+     * Initial settings are configured with the defaultDomainSettings application option via manifest.
+     * Domain settings can be overwritten during runtime with System.setDomainSettings.
+     * @example
+     * ```js
+     * const domainSettings = await fin.System.getDomainSettings();
+     * // {
+     * //     "rules": [
+     * //         {
+     * //             "match": [
+     * //                 "https://openfin.co"
+     * //             ],
+     * //             "options": {
+     * //                 "downloadSettings": {
+     * //                     "rules": [
+     * //                         {
+     * //                             "match": [
+     * //                                 ""
+     * //                             ],
+     * //                             "behavior": "prompt"
+     * //                         }
+     * //                     ]
+     * //                 }
+     * //             }
+     * //         }
+     * //     ]
+     * // }
+     * ```
+     */
+    async getDomainSettings() {
+        const { payload: { data } } = await this.wire.sendAction('get-domain-settings', this.identity);
+        return data;
+    }
+    /**
+     * Sets the domain settings for the current application.
+     * @param domainSettings - domain settings object
+     * @example
+     * ```js
+     * const domainSettings = await fin.System.getDomainSettings();
+     * // {
+     * //     "rules": [
+     * //         {
+     * //             "match": [
+     * //                 "https://openfin.co"
+     * //             ],
+     * //             "options": {
+     * //                 "downloadSettings": {
+     * //                     "rules": [
+     * //                         {
+     * //                             "match": [
+     * //                                 ""
+     * //                             ],
+     * //                             "behavior": "prompt"
+     * //                         }
+     * //                     ]
+     * //                 }
+     * //             }
+     * //         }
+     * //     ]
+     * // }
+     *
+     * // Valid rule behaviors are 'prompt' and 'no-prompt'
+     * domainSettings.rules[0].options.downloadSettings.rules[0].behavior = 'no-prompt';
+     *
+     * await fin.System.setDomainSettings(domainSettings);
+     *
+     * const newDomainSettings = await fin.System.getDomainSettings();
+     * // {
+     * //     "rules": [
+     * //         {
+     * //             "match": [
+     * //                 "https://openfin.co"
+     * //             ],
+     * //             "options": {
+     * //                 "downloadSettings": {
+     * //                     "rules": [
+     * //                         {
+     * //                             "match": [
+     * //                                 ""
+     * //                             ],
+     * //                             "behavior": "no-prompt"
+     * //                         }
+     * //                     ]
+     * //                 }
+     * //             }
+     * //         }
+     * //     ]
+     * // }
+     * ```
+     */
+    async setDomainSettings(domainSettings) {
+        await this.wire.sendAction('set-domain-settings', { domainSettings, ...this.identity });
+    }
+    /**
+     * Attempts to install and enable extensions for the security realm.  Users may want to call this function in response
+     * to an `extensions-install-failed` event.  Only extensions allowed by every application on the current security realm
+     * will be installed/enabled.
+     */
+    async refreshExtensions() {
+        const { payload } = await this.wire.sendAction('refresh-extensions');
+        return payload.data;
+    }
+    /**
+     * Gets the currently-installed
+     */
+    async getInstalledExtensions() {
+        const { payload } = await this.wire.sendAction('get-installed-extensions');
+        return payload.data;
+    }
+}
+system.System = System;
+
+var interappbus = {};
+
+var refCounter = {};
+
+Object.defineProperty(refCounter, "__esModule", { value: true });
+refCounter.RefCounter = void 0;
+class RefCounter {
+    constructor() {
+        this.topicRefMap = new Map();
+    }
+    // returns the ref count after incrementing
+    incRefCount(key) {
+        const refCount = this.topicRefMap.get(key);
+        let returnCount;
+        if (!refCount) {
+            this.topicRefMap.set(key, 1);
+            returnCount = 1;
+        }
+        else {
+            const newRefCount = refCount + 1;
+            returnCount = newRefCount;
+            this.topicRefMap.set(key, newRefCount);
+        }
+        return returnCount;
+    }
+    // returns the ref count after decrementing, or -1 if the key already had no references
+    decRefCount(key) {
+        const refCount = this.topicRefMap.get(key);
+        let returnCount;
+        if (refCount) {
+            const newRefCount = refCount - 1;
+            this.topicRefMap.set(key, newRefCount);
+            returnCount = newRefCount;
+        }
+        else {
+            returnCount = -1;
+        }
+        return returnCount;
+    }
+    // Execute firstAction if it is the first such ref, else execute nonFirstAction.
+    // In either case the return value is that of the action executed
+    actOnFirst(key, firstAction, nonFirstAction) {
+        const numRefs = this.incRefCount(key);
+        const isFirstRef = numRefs === 1;
+        return isFirstRef ? firstAction() : nonFirstAction();
+    }
+    // Execute lastAction if it is the first such ref, else execute nonLastAction.
+    // In either case the return value is that of the action executed
+    actOnLast(key, lastAction, nonLastAction) {
+        const numRefs = this.decRefCount(key);
+        const isLastRef = numRefs === 0;
+        return isLastRef ? lastAction() : nonLastAction();
+    }
+}
+refCounter.RefCounter = RefCounter;
+
+var channel$1 = {};
+
+var client = {};
+
+var channel = {};
+
+Object.defineProperty(channel, "__esModule", { value: true });
+channel.ChannelBase = channel.ProtectedItems = void 0;
+const resultOrPayload = (func) => async (topic, payload, senderIdentity) => {
+    const res = await func(topic, payload, senderIdentity);
+    return res === undefined ? payload : res;
+};
+class ProtectedItems {
+    /**
+     * @internal
+     */
+    // eslint-disable-next-line no-useless-constructor
+    constructor(providerIdentity, close) {
+        this.providerIdentity = providerIdentity;
+        this.close = close;
+    }
+}
+channel.ProtectedItems = ProtectedItems;
+class ChannelBase {
+    static defaultAction(topic) {
+        throw new Error(`No action registered at target for ${topic}`);
+    }
+    constructor() {
+        this.subscriptions = new Map();
+    }
+    async processAction(topic, payload, senderIdentity) {
+        try {
+            const mainAction = this.subscriptions.has(topic)
+                ? this.subscriptions.get(topic)
+                : (currentPayload, id) => (this.defaultAction ?? ChannelBase.defaultAction)(topic, currentPayload, id);
+            const preActionProcessed = this.preAction ? await this.preAction(topic, payload, senderIdentity) : payload;
+            const actionProcessed = await mainAction(preActionProcessed, senderIdentity);
+            return this.postAction ? await this.postAction(topic, actionProcessed, senderIdentity) : actionProcessed;
+        }
+        catch (e) {
+            if (this.errorMiddleware) {
+                return this.errorMiddleware(topic, e, senderIdentity);
+            }
+            throw e;
+        }
+    }
+    /**
+     * Register middleware that fires before the action.
+     *
+     * @param func
+     *
+     * @example
+     *
+     * Channel Provider:
+     * ```js
+     * (async ()=> {
+     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');
+     *
+     *     provider.register('provider-action', (payload, identity) => {
+     *         console.log(payload, identity);
+     *         return {
+     *             echo: payload
+     *         };
+     *     });
+     *
+     *     provider.beforeAction((action, payload, identity) => {
+     *         //The payload can be altered here before handling the action.
+     *         payload.received = Date.now();
+     *         return payload;
+     *     });
+     *
+     * })();
+     * ```
+     *
+     * Channel Client:
+     * ```js
+     * (async ()=> {
+     *     const client = await fin.InterApplicationBus.Channel.connect('channelName');
+     *
+     *     client.register('client-action', (payload, identity) => {
+     *         console.log(payload, identity);
+     *         return {
+     *             echo: payload
+     *         };
+     *     });
+     *
+     *     client.beforeAction((action, payload, identity) => {
+     *         //The payload can be altered here before handling the action.
+     *         payload.received = Date.now();
+     *         return payload;
+     *     });
+     *
+     *     const providerResponse = await client.dispatch('provider-action', { message: 'Hello From the client' });
+     *     console.log(providerResponse);
+     * })();
+     * ```
+     */
+    beforeAction(func) {
+        if (this.preAction) {
+            throw new Error('Already registered beforeAction middleware');
+        }
+        this.preAction = resultOrPayload(func);
+    }
+    /**
+     * Register an error handler. This is called before responding on any error.
+     *
+     * @param func
+     *
+     * Channel Provider:
+     * ```js
+     * (async ()=> {
+     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');
+     *
+     *     provider.register('provider-action', (payload, identity) => {
+     *         console.log(payload);
+     *         throw new Error('Action error');
+     *         return {
+     *             echo: payload
+     *         };
+     *     });
+     *
+     *     provider.onError((action, error, identity) => {
+     *         console.log('uncaught Exception in action:', action);
+     *         console.error(error);
+     *     });
+     *
+     * })();
+     * ```
+     *
+     * Channel Client:
+     * ```js
+     * (async ()=> {
+     *     const client = await fin.InterApplicationBus.Channel.connect('channelName');
+     *
+     *     client.register('client-action', (payload, identity) => {
+     *         console.log(payload);
+     *         throw new Error('Action error');
+     *         return {
+     *             echo: payload
+     *         };
+     *     });
+     *
+     *     client.onError((action, error, identity) => {
+     *         console.log('uncaught Exception in action:', action);
+     *         console.error(error);
+     *     });
+     * })();
+     * ```
+     */
+    onError(func) {
+        if (this.errorMiddleware) {
+            throw new Error('Already registered error middleware');
+        }
+        this.errorMiddleware = func;
+    }
+    /**
+     * Register middleware that fires after the action.
+     *
+     * @param func
+     *
+     * @remarks If the action does not return the payload, then the afterAction will not have access to the payload object.
+     *
+     * @example
+     *
+     * Channel Provider:
+     * ```js
+     * (async ()=> {
+     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');
+     *
+     *     await provider.register('provider-action', (payload, identity) => {
+     *         return {
+     *             echo: payload
+     *         };
+     *     });
+     *
+     *     await provider.afterAction((action, payload, identity) => {
+     *         //the payload can be altered here after handling the action but before sending an acknowledgement.
+     *         payload.sent = date.now();
+     *         return payload;
+     *     });
+     *
+     * })();
+     * ```
+     *
+     * Channel Client:
+     * ```js
+     * (async ()=> {
+     *     const client = await fin.InterApplicationBus.Channel.connect('channelName');
+     *
+     *     await client.register('client-action', (payload, identity) => {
+     *         return {
+     *             echo: payload
+     *         };
+     *     });
+     *
+     *     await client.afterAction((action, payload, identity) => {
+     *         //the payload can be altered here after handling the action but before sending an acknowledgement.
+     *         payload.sent = date.now();
+     *         return payload;
+     *     });
+     *
+     * })();
+     * ```
+     */
+    afterAction(func) {
+        if (this.postAction) {
+            throw new Error('Already registered afterAction middleware');
+        }
+        this.postAction = resultOrPayload(func);
+    }
+    /**
+     * Remove an action by action name.
+     *
+     * @param action
+     *
+     * @example
+     *
+     * ```js
+     * (async ()=> {
+     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');
+     *
+     *     await provider.register('provider-action', (payload, identity) => {
+     *         console.log(payload);
+     *         return {
+     *             echo: payload
+     *         };
+     *     });
+     *
+     *     await provider.remove('provider-action');
+     *
+     * })();
+     * ```
+     */
+    remove(action) {
+        this.subscriptions.delete(action);
+    }
+    /**
+     * Registers a default action. This is used any time an action that has not been registered is invoked.
+     *
+     * @example
+     *
+     * Channel Provider:
+     * ```js
+     * (async ()=> {
+     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');
+     *
+     *     await provider.setDefaultAction((action, payload, identity) => {
+     *         console.log(`Client with identity ${JSON.stringify(identity)} has attempted to dispatch unregistered action: ${action}.`);
+     *
+     *         return {
+     *             echo: payload
+     *         };
+     *     });
+     *
+     * })();
+     * ```
+     *
+     * Channel Client:
+     * ```js
+     * (async ()=> {
+     *     const client = await fin.InterApplicationBus.Channel.connect('channelName');
+     *
+     *     await client.setDefaultAction((action, payload, identity) => {
+     *         console.log(`Provider with identity ${JSON.stringify(identity)} has attempted to dispatch unregistered action: ${action}.`);
+     *
+     *         return {
+     *             echo: payload
+     *         };
+     *     });
+     *
+     * })();
+     * ```
+     * @param func
+     */
+    setDefaultAction(func) {
+        if (this.defaultAction) {
+            throw new Error('default action can only be set once');
+        }
+        else {
+            this.defaultAction = func;
+        }
+    }
+    /**
+     * Register an action to be called by dispatching from any channelClient or channelProvider.
+     *
+     * @param topic
+     * @param listener
+     *
+     * @remarks The return value will be sent back as an acknowledgement to the original caller. You can throw an
+     * error to send a negative-acknowledgement and the error will reject the promise returned to the sender by the
+     * dispatch call.  Once a listener is registered for a particular action, it stays in place receiving and responding
+     * to incoming messages until it is removed.  This messaging mechanism works exactly the same when messages are
+     * dispatched from the provider to a client.  However, the provider has an additional publish method that sends messages
+     * to all connected clients.
+     *
+     * Because multiple clients can share the same `name` and `uuid`, in order to distinguish between individual clients,
+     * the `identity` argument in a provider's registered action callback contains an `endpointId` property. When dispatching
+     * from a provider to a client, the `endpointId` property must be provided in order to send an action to a specific client.
+     *
+     * @example
+     *
+     * Channel Provider:
+     * ```js
+     * (async ()=> {
+     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');
+     *
+     *     await provider.register('provider-action', (payload, identity) => {
+     *        console.log('Action dispatched by client: ', identity);
+     *        console.log('Payload sent in dispatch: ', payload);
+     *
+     *        return { echo: payload };
+     *    });
+     * })();
+     * ```
+     *
+     * Channel Client:
+     * ```js
+     * (async ()=> {
+     *     const client = await fin.InterApplicationBus.Channel.connect('channelName');
+     *
+     *     await client.register('client-action', (payload, identity) => {
+     *        console.log('Action dispatched by client: ', identity);
+     *        console.log('Payload sent in dispatch: ', payload);
+     *
+     *        return { echo: payload };
+     *    });
+     * })();
+     * ```
+     */
+    register(topic, listener) {
+        if (this.subscriptions.has(topic)) {
+            throw new Error(`Subscription already registered for action: ${topic}. Unsubscribe before adding new subscription`);
+        }
+        else {
+            this.subscriptions.set(topic, listener);
+            return true;
+        }
+    }
+}
+channel.ChannelBase = ChannelBase;
+
+var __classPrivateFieldGet$c = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet$a = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _ChannelClient_protectedObj, _ChannelClient_strategy, _ChannelClient_close;
+Object.defineProperty(client, "__esModule", { value: true });
+client.ChannelClient = void 0;
+const channel_1$1 = channel;
+const channelClientsByEndpointId = new Map();
+/**
+ * Instance created to enable use of a channel as a client.  Allows for communication with the
+ * {@link ChannelProvider ChannelProvider} by invoking an action on the
+ * provider via {@link ChannelClient#dispatch dispatch} and to listen for communication
+ * from the provider by registering an action via {@link ChannelClient#register register}.
+ *
+ * ### Synchronous Methods:
+ *  * {@link ChannelClient#onDisconnection onDisconnection(listener)}
+ *  * {@link ChannelClient#register register(action, listener)}
+ *  * {@link ChannelClient#remove remove(action)}
+ *
+ * ### Asynchronous Methods:
+ *  * {@link ChannelClient#disconnect disconnect()}
+ *  * {@link ChannelClient#dispatch dispatch(action, payload)}
+ *
+ * ### Middleware:
+ * Middleware functions receive the following arguments: (action, payload, senderId).
+ * The return value of the middleware function will be passed on as the payload from beforeAction, to the action listener, to afterAction
+ * unless it is undefined, in which case the original payload is used.  Middleware can be used for side effects.
+ *  * {@link ChannelClient#setDefaultAction setDefaultAction(middleware)}
+ *  * {@link ChannelClient#onError onError(middleware)}
+ *  * {@link ChannelClient#beforeAction beforeAction(middleware)}
+ *  * {@link ChannelClient#afterAction afterAction(middleware)}
+ */
+class ChannelClient extends channel_1$1.ChannelBase {
+    /**
+     * @internal
+     */
+    static closeChannelByEndpointId(id) {
+        const channel = channelClientsByEndpointId.get(id);
+        if (channel) {
+            __classPrivateFieldGet$c(channel, _ChannelClient_close, "f").call(channel);
+        }
+    }
+    /**
+     * @internal
+     * closes the corresponding channel and invokes the disconnect listener if an event payload is passed.
+     */
+    static handleProviderDisconnect(eventPayload) {
+        for (const channelClient of channelClientsByEndpointId.values()) {
+            if (channelClient.providerIdentity.channelId === eventPayload.channelId) {
+                channelClient.disconnectListener(eventPayload);
+                __classPrivateFieldGet$c(channelClient, _ChannelClient_close, "f").call(channelClient);
+            }
+        }
+    }
+    /**
+     * @internal
+     */
+    constructor(routingInfo, close, strategy) {
+        super();
+        _ChannelClient_protectedObj.set(this, void 0);
+        _ChannelClient_strategy.set(this, void 0);
+        // needs to be bound;
+        this.processAction = (action, payload, senderIdentity) => super.processAction(action, payload, senderIdentity);
+        _ChannelClient_close.set(this, () => {
+            channelClientsByEndpointId.delete(this.endpointId);
+            __classPrivateFieldGet$c(this, _ChannelClient_strategy, "f").close();
+        });
+        __classPrivateFieldSet$a(this, _ChannelClient_protectedObj, new channel_1$1.ProtectedItems(routingInfo, close), "f");
+        this.disconnectListener = () => undefined;
+        this.endpointId = routingInfo.endpointId;
+        __classPrivateFieldSet$a(this, _ChannelClient_strategy, strategy, "f");
+        channelClientsByEndpointId.set(this.endpointId, this);
+        strategy.receive(this.processAction);
+    }
+    /**
+     * a read-only provider identity
+     */
+    get providerIdentity() {
+        const protectedObj = __classPrivateFieldGet$c(this, _ChannelClient_protectedObj, "f");
+        return protectedObj.providerIdentity;
+    }
+    /**
+     * Dispatch the given action to the channel provider. Returns a promise that resolves with the response from
+     * the provider for that action.
+     *
+     * @param action
+     * @param payload
+     *
+     * @example
+     *
+     * ```js
+     * (async ()=> {
+     *     const client = await fin.InterApplicationBus.Channel.connect('channelName');
+     *
+     *     await client.register('client-action', (payload, identity) => {
+     *         console.log(payload, identity);
+     *         return {
+     *             echo: payload
+     *         };
+     *     });
+     *
+     *     const providerResponse = await client.dispatch('provider-action', { message: 'Hello From the client'});
+     *     console.log(providerResponse);
+     * })();
+     * ```
+     */
+    async dispatch(action, payload) {
+        if (__classPrivateFieldGet$c(this, _ChannelClient_strategy, "f").isEndpointConnected(this.providerIdentity.channelId)) {
+            return __classPrivateFieldGet$c(this, _ChannelClient_strategy, "f").send(this.providerIdentity.channelId, action, payload);
+        }
+        throw new Error('The client you are trying to dispatch from is disconnected from the target provider.');
+    }
+    /**
+     * Register a listener that is called on provider disconnection. It is passed the disconnection event of the
+     * disconnecting provider.
+     *
+     * @param listener
+     *
+     * @example
+     *
+     * ```js
+     * (async ()=> {
+     *     const client = await fin.InterApplicationBus.Channel.connect('channelName');
+     *
+     *     await client.onDisconnection(evt => {
+     *         console.log('Provider disconnected', `uuid: ${evt.uuid}, name: ${evt.name}`);
+     *     });
+     * })();
+     * ```
+     */
+    onDisconnection(listener) {
+        this.disconnectListener = (payload) => {
+            try {
+                listener(payload);
+            }
+            catch (err) {
+                throw new Error(`Error while calling the onDisconnection callback: ${err.message}`);
+            }
+            finally {
+                this.disconnectListener = () => undefined;
+            }
+        };
+    }
+    /**
+     * Disconnects the client from the channel.
+     *
+     * @example
+     *
+     * ```js
+     * (async ()=> {
+     *     const client = await fin.InterApplicationBus.Channel.connect('channelName');
+     *
+     *     await client.disconnect();
+     * })();
+     * ```
+     */
+    async disconnect() {
+        await this.sendDisconnectAction();
+        __classPrivateFieldGet$c(this, _ChannelClient_close, "f").call(this);
+    }
+    async sendDisconnectAction() {
+        const protectedObj = __classPrivateFieldGet$c(this, _ChannelClient_protectedObj, "f");
+        await protectedObj.close();
+    }
+    /**
+     * @internal
+     * Writing this as a static to keep code together, but in environments with a wire, this will be DI'd into the protectedObject class as close.
+     */
+    static async wireClose(wire, providerIdentity, endpointId) {
+        const { channelName, uuid, name } = providerIdentity;
+        await wire.sendAction('disconnect-from-channel', {
+            channelName,
+            uuid,
+            name,
+            endpointId
+        });
+    }
+}
+client.ChannelClient = ChannelClient;
+_ChannelClient_protectedObj = new WeakMap(), _ChannelClient_strategy = new WeakMap(), _ChannelClient_close = new WeakMap();
+
+var connectionManager = {};
+
+var exhaustive = {};
+
+Object.defineProperty(exhaustive, "__esModule", { value: true });
+exhaustive.exhaustiveCheck = void 0;
+function exhaustiveCheck(value, allowed) {
+    throw new Error(`Unsupported value: ${value}${allowed ? `\n Supported values are: ${allowed.join('')}` : ''}`);
+}
+exhaustive.exhaustiveCheck = exhaustiveCheck;
+
+var strategy$3 = {};
+
+var __classPrivateFieldSet$9 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet$b = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ClassicStrategy_wire, _ClassicStrategy_endpointIdentityMap, _ClassicStrategy_pendingMessagesByEndpointId;
+Object.defineProperty(strategy$3, "__esModule", { value: true });
+strategy$3.ClassicInfo = strategy$3.ClassicStrategy = void 0;
+/*
+This is used to abstract out ipc messaging from the channels implementation. It is only concerned with sending messages and registration with the MessageReceiver
+*/
+class ClassicStrategy {
+    constructor(wire, messageReceiver, endpointId, // Provider endpointId is channelId
+    providerIdentity) {
+        this.messageReceiver = messageReceiver;
+        this.endpointId = endpointId;
+        this.providerIdentity = providerIdentity;
+        _ClassicStrategy_wire.set(this, void 0);
+        // Store full endpointIdentity by endpointId of all known endpoints for this strategy instance.
+        // (clients will only have 1: the provider, the provider will have all clients)
+        _ClassicStrategy_endpointIdentityMap.set(this, new Map());
+        // Store a set of cancellable promises to be able to reject them when client
+        // connection problems occur
+        _ClassicStrategy_pendingMessagesByEndpointId.set(this, new Map);
+        this.send = async (endpointId, action, payload) => {
+            const to = __classPrivateFieldGet$b(this, _ClassicStrategy_endpointIdentityMap, "f").get(endpointId);
+            if (!to) {
+                throw new Error(`Could not locate routing info for endpoint ${endpointId}`);
+            }
+            // as casting to any because typescript complains. The following is only relevant if this is a locally set endpointId on a ClientIdentity.
+            // We delete these properties to not change backwards compatibility.
+            const cleanId = { ...to };
+            if (cleanId.isLocalEndpointId) {
+                delete cleanId.endpointId;
+            }
+            delete cleanId.isLocalEndpointId;
+            // grab the promise before awaiting it to save in our pending messages map
+            const p = __classPrivateFieldGet$b(this, _ClassicStrategy_wire, "f")
+                .sendAction('send-channel-message', {
+                ...cleanId,
+                providerIdentity: this.providerIdentity,
+                action,
+                payload
+            });
+            __classPrivateFieldGet$b(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").get(endpointId)?.add(p);
+            const raw = await p.catch((error) => {
+                throw new Error(error.message);
+            }).finally(() => {
+                // clean up the pending promise
+                __classPrivateFieldGet$b(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").get(endpointId)?.delete(p);
+            });
+            return raw.payload.data.result;
+        };
+        this.close = async () => {
+            this.messageReceiver.removeEndpoint(this.providerIdentity.channelId, this.endpointId);
+            [...__classPrivateFieldGet$b(this, _ClassicStrategy_endpointIdentityMap, "f").keys()].forEach((id) => this.closeEndpoint(id));
+            __classPrivateFieldSet$9(this, _ClassicStrategy_endpointIdentityMap, new Map(), "f");
+        };
+        __classPrivateFieldSet$9(this, _ClassicStrategy_wire, wire, "f");
+    }
+    onEndpointDisconnect(endpointId, listener) {
+        // Never fires for 'classic'.
+    }
+    receive(listener) {
+        this.messageReceiver.addEndpoint(listener, this.providerIdentity.channelId, this.endpointId);
+    }
+    async closeEndpoint(endpointId) {
+        const id = __classPrivateFieldGet$b(this, _ClassicStrategy_endpointIdentityMap, "f").get(endpointId);
+        __classPrivateFieldGet$b(this, _ClassicStrategy_endpointIdentityMap, "f").delete(endpointId);
+        const pendingSet = __classPrivateFieldGet$b(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").get(endpointId);
+        pendingSet?.forEach((p) => {
+            const errorMsg = `Channel connection with identity uuid: ${id?.uuid} / name: ${id?.name} / endpointId: ${endpointId} no longer connected.`;
+            p.cancel(new Error(errorMsg));
+        });
+    }
+    isEndpointConnected(endpointId) {
+        return __classPrivateFieldGet$b(this, _ClassicStrategy_endpointIdentityMap, "f").has(endpointId);
+    }
+    addEndpoint(endpointId, payload) {
+        __classPrivateFieldGet$b(this, _ClassicStrategy_endpointIdentityMap, "f").set(endpointId, payload.endpointIdentity);
+        __classPrivateFieldGet$b(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").set(endpointId, new Set());
+    }
+    isValidEndpointPayload(payload) {
+        return (typeof payload?.endpointIdentity?.endpointId === 'string' ||
+            typeof payload?.endpointIdentity?.channelId === 'string');
+    }
+}
+strategy$3.ClassicStrategy = ClassicStrategy;
+_ClassicStrategy_wire = new WeakMap(), _ClassicStrategy_endpointIdentityMap = new WeakMap(), _ClassicStrategy_pendingMessagesByEndpointId = new WeakMap();
+// Arbitrarily starting at 5 to leave the door open to backfilling pre endpointId etc.
+strategy$3.ClassicInfo = { version: 5, minimumVersion: 0, type: 'classic' };
+
+var strategy$2 = {};
+
+var endpoint = {};
+
+var errors = {};
+
+Object.defineProperty(errors, "__esModule", { value: true });
+errors.errorToPOJO = void 0;
+function errorToPOJO(error) {
+    return {
+        stack: error.stack,
+        name: error.name,
+        message: error.message,
+        // support the case where stack is empty or missing
+        toString: () => error.stack || error.toString()
+    };
+}
+errors.errorToPOJO = errorToPOJO;
+
+var __classPrivateFieldGet$a = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet$8 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _RTCEndpoint_processAction, _RTCEndpoint_disconnectListener;
+Object.defineProperty(endpoint, "__esModule", { value: true });
+endpoint.RTCEndpoint = void 0;
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const errors_1$1 = errors;
+/*
+This handles sending RTC messages between RTC connections over the request and response data channels.
+*/
+class RTCEndpoint {
+    static isValidEndpointPayload(payload) {
+        const isObject = (x) => {
+            return typeof x === 'object' && x !== null;
+        };
+        return (
+        // TODO in factory PR:
+        // payload.type === 'rtc' &&
+        isObject(payload) &&
+            isObject(payload.endpointIdentity) &&
+            isObject(payload.rtc) &&
+            typeof payload.endpointIdentity.endpointId === 'string');
+    }
+    constructor({ rtc, endpointIdentity }) {
+        this.responseMap = new Map();
+        _RTCEndpoint_processAction.set(this, null);
+        _RTCEndpoint_disconnectListener.set(this, void 0);
+        this.connectionStateChangeHandler = (event) => {
+            if (this.rtc.rtcClient.connectionState !== 'connected') {
+                this.rtc.rtcClient.removeEventListener('connectionstatechange', this.connectionStateChangeHandler);
+                this.close();
+                if (__classPrivateFieldGet$a(this, _RTCEndpoint_disconnectListener, "f")) {
+                    __classPrivateFieldGet$a(this, _RTCEndpoint_disconnectListener, "f").call(this);
+                }
+            }
+        };
+        this.send = async (action, payload) => {
+            const messageId = `message-${Math.random()}`;
+            const promise = new Promise((resolve, reject) => {
+                this.responseMap.set(messageId, { resolve, reject });
+            });
+            this.rtc.channels.request.send(JSON.stringify({ action, payload, messageId }));
+            return promise;
+        };
+        this.close = () => {
+            this.responseMap.forEach((response) => response.reject('Connection has closed.'));
+            this.responseMap = new Map();
+            this.rtc.channels.request.close();
+            this.rtc.channels.response.close();
+            this.rtc.rtcClient.close();
+        };
+        this.rtc = rtc;
+        this.endpointIdentity = endpointIdentity;
+        this.rtc.channels.response.addEventListener('message', (e) => {
+            let { data } = e;
+            if (e.data instanceof ArrayBuffer) {
+                data = new TextDecoder().decode(e.data);
+            }
+            const { messageId, payload, success, error } = JSON.parse(data);
+            const { resolve, reject } = this.responseMap.get(messageId) ?? {};
+            if (resolve && reject) {
+                this.responseMap.delete(messageId);
+                if (success) {
+                    resolve(payload);
+                }
+                else {
+                    reject(error);
+                }
+            }
+            else {
+                console.log('Could not find id in responseMap.');
+                console.log(e);
+            }
+        });
+        this.rtc.channels.request.addEventListener('message', async (e) => {
+            let { data } = e;
+            if (e.data instanceof ArrayBuffer) {
+                data = new TextDecoder().decode(e.data);
+            }
+            const { messageId, action, payload } = JSON.parse(data);
+            if (__classPrivateFieldGet$a(this, _RTCEndpoint_processAction, "f")) {
+                try {
+                    const res = await __classPrivateFieldGet$a(this, _RTCEndpoint_processAction, "f").call(this, action, payload, endpointIdentity);
+                    this.rtc.channels.response.send(JSON.stringify({
+                        messageId,
+                        payload: res,
+                        success: true
+                    }));
+                }
+                catch (error) {
+                    // Check if RTCDataChannel is open before sending, error gets swallowed here in the case where
+                    // client dispatched then closed or disconnected before the dispatch resolves.
+                    if (this.rtc.channels.response.readyState === 'open') {
+                        this.rtc.channels.response.send(JSON.stringify({
+                            messageId,
+                            error: (0, errors_1$1.errorToPOJO)(error),
+                            success: false
+                        }));
+                    }
+                }
+                // Check if RTCDataChannel is open for same reason as catch block above.
+            }
+            else if (this.rtc.channels.response.readyState === 'open') {
+                this.rtc.channels.response.send(JSON.stringify({
+                    messageId,
+                    success: false,
+                    error: 'Connection not ready.'
+                }));
+            }
+        });
+        this.rtc.rtcClient.addEventListener('connectionstatechange', this.connectionStateChangeHandler);
+        // Disconnect if data channels close unexpectedly, e.g. can happen due to message size > ~255kB (RTCPeerConnection.sctp.maxMessageSizeLimit: 262144)
+        Object.values(this.rtc.channels).forEach((datachannel) => {
+            datachannel.onclose = (e) => {
+                [...this.responseMap.values()].forEach((promise) => promise.reject(new Error('RTCDataChannel closed unexpectedly, this is most commonly caused by message size. Note: RTC Channels have a message size limit of ~255kB.')));
+                this.close();
+                if (__classPrivateFieldGet$a(this, _RTCEndpoint_disconnectListener, "f")) {
+                    __classPrivateFieldGet$a(this, _RTCEndpoint_disconnectListener, "f").call(this);
+                }
+            };
+        });
+    }
+    onDisconnect(listener) {
+        if (!__classPrivateFieldGet$a(this, _RTCEndpoint_disconnectListener, "f")) {
+            __classPrivateFieldSet$8(this, _RTCEndpoint_disconnectListener, listener, "f");
+        }
+        else {
+            throw new Error('RTCEndpoint disconnectListener cannot be set twice.');
+        }
+    }
+    receive(listener) {
+        if (__classPrivateFieldGet$a(this, _RTCEndpoint_processAction, "f")) {
+            throw new Error('You have already set a listener for this RTC Endpoint.');
+        }
+        __classPrivateFieldSet$8(this, _RTCEndpoint_processAction, listener, "f");
+    }
+    get connected() {
+        return this.rtc.rtcClient.connectionState === 'connected';
+    }
+}
+endpoint.RTCEndpoint = RTCEndpoint;
+_RTCEndpoint_processAction = new WeakMap(), _RTCEndpoint_disconnectListener = new WeakMap();
+
+var strategy$1 = {};
+
+var __classPrivateFieldGet$9 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet$7 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _EndpointStrategy_processAction, _EndpointStrategy_endpointMap, _EndpointStrategy_connected;
+Object.defineProperty(strategy$1, "__esModule", { value: true });
+strategy$1.EndpointStrategy = void 0;
+class EndpointStrategy {
+    // Need to pass in validate endpoint separately from constructor because ts interfaces don't do well with static methods
+    constructor(EndpointType, validateEndpoint, StrategyName) {
+        this.EndpointType = EndpointType;
+        this.StrategyName = StrategyName;
+        _EndpointStrategy_processAction.set(this, null);
+        _EndpointStrategy_endpointMap.set(this, new Map());
+        _EndpointStrategy_connected.set(this, true);
+        this.send = async (endpointId, action, payload) => {
+            return this.getEndpointById(endpointId).send(action, payload);
+        };
+        this.close = async () => {
+            if (__classPrivateFieldGet$9(this, _EndpointStrategy_connected, "f")) {
+                __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, "f").forEach((endpoint) => endpoint.close());
+                __classPrivateFieldSet$7(this, _EndpointStrategy_endpointMap, new Map(), "f");
+            }
+            __classPrivateFieldSet$7(this, _EndpointStrategy_connected, false, "f");
+        };
+        this.isValidEndpointPayload = validateEndpoint;
+    }
+    onEndpointDisconnect(endpointId, listener) {
+        this.getEndpointById(endpointId).onDisconnect(listener);
+    }
+    receive(listener) {
+        if (__classPrivateFieldGet$9(this, _EndpointStrategy_processAction, "f")) {
+            throw new Error(`You have already set a listener for this ${this.StrategyName} Strategy`);
+        }
+        __classPrivateFieldSet$7(this, _EndpointStrategy_processAction, listener, "f");
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, "f").forEach((endpoint) => endpoint.receive(__classPrivateFieldGet$9(this, _EndpointStrategy_processAction, "f")));
+    }
+    getEndpointById(endpointId) {
+        const endpoint = __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, "f").get(endpointId);
+        if (!endpoint) {
+            throw new Error(`Client with endpoint id ${endpointId} is not connected`);
+        }
+        return endpoint;
+    }
+    get connected() {
+        return __classPrivateFieldGet$9(this, _EndpointStrategy_connected, "f");
+    }
+    isEndpointConnected(endpointId) {
+        return __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, "f").has(endpointId);
+    }
+    addEndpoint(endpointId, payload) {
+        if (!__classPrivateFieldGet$9(this, _EndpointStrategy_connected, "f")) {
+            console.warn(`Adding endpoint to disconnected ${this.StrategyName} Strategy`);
+            return;
+        }
+        const clientStrat = new this.EndpointType(payload);
+        if (__classPrivateFieldGet$9(this, _EndpointStrategy_processAction, "f")) {
+            clientStrat.receive(__classPrivateFieldGet$9(this, _EndpointStrategy_processAction, "f"));
+        }
+        __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, "f").set(endpointId, clientStrat);
+    }
+    async closeEndpoint(endpointId) {
+        __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, "f").delete(endpointId);
+    }
+}
+strategy$1.EndpointStrategy = EndpointStrategy;
+_EndpointStrategy_processAction = new WeakMap(), _EndpointStrategy_endpointMap = new WeakMap(), _EndpointStrategy_connected = new WeakMap();
+
+Object.defineProperty(strategy$2, "__esModule", { value: true });
+strategy$2.RTCInfo = strategy$2.RTCStrategy = void 0;
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable class-methods-use-this */
+const endpoint_1 = endpoint;
+const strategy_1$1 = strategy$1;
+/*
+This is used to abstract out rtc messaging from the channels implementation using RTCEndpoints.
+*/
+class RTCStrategy extends strategy_1$1.EndpointStrategy {
+    constructor() {
+        super(endpoint_1.RTCEndpoint, endpoint_1.RTCEndpoint.isValidEndpointPayload, 'RTC');
+    }
+}
+strategy$2.RTCStrategy = RTCStrategy;
+strategy$2.RTCInfo = { version: 2, minimumVersion: 0, type: 'rtc' };
+
+var iceManager = {};
+
+Object.defineProperty(iceManager, "__esModule", { value: true });
+iceManager.RTCICEManager = void 0;
+const base_1$h = base;
+/*
+Singleton that facilitates Offer and Answer exchange required for establishing RTC connections.
+*/
+class RTCICEManager extends base_1$h.EmitterBase {
+    constructor(wire) {
+        super(wire, 'channel');
+        this.ensureChannelOpened = (channel) => {
+            return new Promise((resolve, reject) => {
+                if (channel.readyState === 'open') {
+                    resolve();
+                }
+                else if (channel.readyState === 'connecting') {
+                    const listener = () => {
+                        channel.removeEventListener('open', listener);
+                        resolve();
+                    };
+                    channel.addEventListener('open', listener);
+                }
+                else {
+                    reject(new Error('This Channel has already closed'));
+                }
+            });
+        };
+    }
+    static createDataChannelPromise(label, rtcClient) {
+        let resolver;
+        const promise = new Promise((resolve) => {
+            resolver = resolve;
+        });
+        const listener = (e) => {
+            const openListener = () => {
+                e.channel.removeEventListener('open', openListener);
+                resolver(e.channel);
+            };
+            if (e.channel.label === label) {
+                e.channel.addEventListener('open', openListener);
+                rtcClient.removeEventListener('datachannel', listener);
+            }
+        };
+        rtcClient.addEventListener('datachannel', listener);
+        return promise;
+    }
+    async listenForProviderIce(rtcConnectionId, listener) {
+        await this.on(this.createProviderEventName(rtcConnectionId), listener, { timestamp: Date.now() });
+    }
+    async raiseProviderIce(rtcConnectionId, payload) {
+        await this.wire.environment.raiseEvent(this.createRouteString(this.createProviderEventName(rtcConnectionId)), payload);
+    }
+    async listenForClientIce(rtcConnectionId, listener) {
+        await this.on(this.createClientEventName(rtcConnectionId), listener, { timestamp: Date.now() });
+    }
+    async raiseClientIce(rtcConnectionId, payload) {
+        await this.wire.environment.raiseEvent(this.createRouteString(this.createClientEventName(rtcConnectionId)), payload);
+    }
+    cleanupIceListeners(rtcConnectionId) {
+        this.removeAllListeners(this.createClientEventName(rtcConnectionId));
+        this.removeAllListeners(this.createProviderEventName(rtcConnectionId));
+    }
+    createClientEventName(rtcConnectionId) {
+        return `ice-client-${rtcConnectionId}`;
+    }
+    createProviderEventName(rtcConnectionId) {
+        return `ice-provider-${rtcConnectionId}`;
+    }
+    createRouteString(name) {
+        return `channel/${name}`;
+    }
+    createRtcPeer() {
+        return this.wire.environment.getRtcPeer();
+    }
+    async startClientOffer() {
+        // TODO replace with real guid.
+        const rtcConnectionId = Math.random().toString();
+        const rtcClient = this.createRtcPeer();
+        rtcClient.addEventListener('icecandidate', async (e) => {
+            if (e.candidate) {
+                await this.raiseClientIce(rtcConnectionId, { candidate: e.candidate?.toJSON() });
+            }
+        });
+        await this.listenForProviderIce(rtcConnectionId, async (payload) => {
+            await rtcClient.addIceCandidate(payload.candidate);
+        });
+        const channels = {
+            request: rtcClient.createDataChannel('request'),
+            response: rtcClient.createDataChannel('response')
+        };
+        const offer = await rtcClient.createOffer();
+        await rtcClient.setLocalDescription(offer);
+        const channelsOpened = Promise.all([channels.request, channels.response].map(this.ensureChannelOpened)).then(() => undefined);
+        return { rtcClient, channels, offer, rtcConnectionId, channelsOpened };
+    }
+    async finishClientOffer(rtcClient, answer, providerReady) {
+        await rtcClient.setRemoteDescription(answer);
+        await providerReady;
+        return true;
+    }
+    async createProviderAnswer(rtcConnectionId, offer) {
+        const rtcClient = this.createRtcPeer();
+        const requestChannelPromise = RTCICEManager.createDataChannelPromise('request', rtcClient);
+        const responseChannelPromise = RTCICEManager.createDataChannelPromise('response', rtcClient);
+        rtcClient.addEventListener('icecandidate', async (e) => {
+            if (e.candidate) {
+                await this.raiseProviderIce(rtcConnectionId, { candidate: e.candidate?.toJSON() });
+            }
+        });
+        await this.listenForClientIce(rtcConnectionId, async (payload) => {
+            await rtcClient.addIceCandidate(payload.candidate);
+        });
+        await rtcClient.setRemoteDescription(offer);
+        const answer = await rtcClient.createAnswer();
+        await rtcClient.setLocalDescription(answer);
+        const channels = Promise.all([requestChannelPromise, responseChannelPromise]).then(([request, response]) => {
+            // Clean up ice events.
+            this.cleanupIceListeners(rtcConnectionId);
+            return { request, response };
+        });
+        return {
+            rtcClient,
+            answer,
+            channels
+        };
+    }
+}
+iceManager.RTCICEManager = RTCICEManager;
+
+var provider = {};
+
+var runtimeVersioning = {};
+
+Object.defineProperty(runtimeVersioning, "__esModule", { value: true });
+runtimeVersioning.runtimeUuidMeetsMinimumRuntimeVersion = runtimeVersioning.parseRuntimeUuid = runtimeVersioning.meetsMinimumRuntimeVersion = void 0;
+function vNum(x) {
+    return [...x.split('.').reverse().entries()].reduce((p, [i, v]) => p + +v * 10000 ** i, 0);
+}
+/*
+  Compares runtime versions to see if the current runtime meets your desired minimum.
+*/
+function meetsMinimumRuntimeVersion(currentVersion, minVersion) {
+    const currentVersionParsed = vNum(currentVersion);
+    const minVersionParsed = vNum(minVersion);
+    return currentVersionParsed >= minVersionParsed;
+}
+runtimeVersioning.meetsMinimumRuntimeVersion = meetsMinimumRuntimeVersion;
+// Strips the port info from the runtimeUuid, leaving just the runtime version.
+function parseRuntimeUuid(runtimeUuid) {
+    return runtimeUuid.split('/')[0];
+}
+runtimeVersioning.parseRuntimeUuid = parseRuntimeUuid;
+function runtimeUuidMeetsMinimumRuntimeVersion(runtimeUuid, minVersion) {
+    const runtimeVersion = parseRuntimeUuid(runtimeUuid);
+    return meetsMinimumRuntimeVersion(runtimeVersion, minVersion);
+}
+runtimeVersioning.runtimeUuidMeetsMinimumRuntimeVersion = runtimeUuidMeetsMinimumRuntimeVersion;
+
+var __classPrivateFieldGet$8 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet$6 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _ChannelProvider_connections, _ChannelProvider_protectedObj, _ChannelProvider_strategy, _ChannelProvider_removeEndpoint, _ChannelProvider_close;
+Object.defineProperty(provider, "__esModule", { value: true });
+provider.ChannelProvider = void 0;
+const channel_1 = channel;
+const runtimeVersioning_1 = runtimeVersioning;
+/**
+ * Instance created to enable use of a channel as a provider. Allows for communication with the {@link ChannelClient ChannelClients} by invoking an action on
+ * a single client via {@link ChannelProvider#dispatch dispatch} or all clients via {@link ChannelProvider#publish publish}
+ * and to listen for communication from clients by registering an action via {@link ChannelProvider#register register}.
+ *
+ * ### Synchronous Methods:
+ *  * {@link ChannelProvider#onConnection onConnection(listener)}
+ *  * {@link ChannelProvider#onDisconnection onDisconnection(listener)}
+ *  * {@link ChannelProvider#publish publish(action, payload)}
+ *  * {@link ChannelProvider#register register(action, listener)}
+ *  * {@link ChannelProvider#remove remove(action)}
+ *
+ * ### Asynchronous Methods:
+ *  * {@link ChannelProvider#destroy destroy()}
+ *  * {@link ChannelProvider#dispatch dispatch(to, action, payload)}
+ *  * {@link ChannelProvider#getAllClientInfo getAllClientInfo()}
+ *
+ * ### Middleware:
+ * Middleware functions receive the following arguments: (action, payload, senderId).
+ * The return value of the middleware function will be passed on as the payload from beforeAction, to the action listener, to afterAction
+ * unless it is undefined, in which case the most recently defined payload is used.  Middleware can be used for side effects.
+ *  * {@link ChannelProvider#setDefaultAction setDefaultAction(middleware)}
+ *  * {@link ChannelProvider#onError onError(middleware)}
+ *  * {@link ChannelProvider#beforeAction beforeAction(middleware)}
+ *  * {@link ChannelProvider#afterAction afterAction(middleware)}
+ */
+class ChannelProvider extends channel_1.ChannelBase {
+    /**
+     * a read-only array containing all the identities of connecting clients.
+     */
+    get connections() {
+        return [...__classPrivateFieldGet$8(this, _ChannelProvider_connections, "f")];
+    }
+    static handleClientDisconnection(channel, payload) {
+        const removeById = channel.connections.find((identity) => identity.endpointId === payload.endpointId);
+        if (removeById) {
+            __classPrivateFieldGet$8(channel, _ChannelProvider_removeEndpoint, "f").call(channel, removeById);
+        }
+        else {
+            const multipleRemoves = channel.connections.filter((identity) => {
+                return identity.uuid === payload.uuid && identity.name === payload.name;
+            });
+            multipleRemoves.forEach(__classPrivateFieldGet$8(channel, _ChannelProvider_removeEndpoint, "f"));
+        }
+        channel.disconnectListener(payload);
+    }
+    static setProviderRemoval(provider, remove) {
+        ChannelProvider.removalMap.set(provider, remove);
+    }
+    /**
+     * @internal
+     */
+    constructor(providerIdentity, close, strategy) {
+        super();
+        _ChannelProvider_connections.set(this, void 0);
+        _ChannelProvider_protectedObj.set(this, void 0);
+        _ChannelProvider_strategy.set(this, void 0);
+        _ChannelProvider_removeEndpoint.set(this, (identity) => {
+            const remainingConnections = this.connections.filter((clientIdentity) => clientIdentity.endpointId !== identity.endpointId);
+            __classPrivateFieldGet$8(this, _ChannelProvider_strategy, "f").closeEndpoint(identity.endpointId);
+            __classPrivateFieldSet$6(this, _ChannelProvider_connections, remainingConnections, "f");
+        });
+        // Must be bound.
+        this.processAction = async (action, payload, senderIdentity) => {
+            if (ChannelProvider.clientIsMultiRuntime(senderIdentity) &&
+                !(0, runtimeVersioning_1.runtimeUuidMeetsMinimumRuntimeVersion)(senderIdentity.runtimeUuid, '18.87.56.0')) {
+                this.handleMultiRuntimeLegacyClient(senderIdentity);
+            }
+            else {
+                this.checkForClientConnection(senderIdentity);
+            }
+            return super.processAction(action, payload, senderIdentity);
+        };
+        _ChannelProvider_close.set(this, () => {
+            __classPrivateFieldGet$8(this, _ChannelProvider_strategy, "f").close();
+            const remove = ChannelProvider.removalMap.get(this);
+            if (remove) {
+                remove();
+            }
+        });
+        __classPrivateFieldSet$6(this, _ChannelProvider_protectedObj, new channel_1.ProtectedItems(providerIdentity, close), "f");
+        this.connectListener = () => undefined;
+        this.disconnectListener = () => undefined;
+        __classPrivateFieldSet$6(this, _ChannelProvider_connections, [], "f");
+        __classPrivateFieldSet$6(this, _ChannelProvider_strategy, strategy, "f");
+        strategy.receive(this.processAction);
+    }
+    /**
+     * Dispatch an action to a specified client. Returns a promise for the result of executing that action on the client side.
+     *
+     * @param to - Identity of the target client.
+     * @param action - Name of the action to be invoked by the client.
+     * @param payload - Payload to be sent along with the action.
+     *
+     * @remarks
+     *
+     * Because multiple clients can share the same `name` and `uuid`, when dispatching from a provider to a client,
+     * the `identity` you provide must include the client's unique `endpointId` property. This `endpointId` is
+     * passed to the provider in both the `Provider.onConnection` callback and in any registered action callbacks.
+     *
+     * @example
+     *
+     * ```js
+     * (async ()=> {
+     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');
+     *
+     *     await provider.register('provider-action', async (payload, identity) => {
+     *         console.log(payload, identity);
+     *         return await provider.dispatch(identity, 'client-action', 'Hello, World!');
+     *     });
+     * })();
+     * ```
+     */
+    dispatch(to, action, payload) {
+        const endpointId = to.endpointId ?? this.getEndpointIdForOpenFinId(to, action);
+        if (endpointId && __classPrivateFieldGet$8(this, _ChannelProvider_strategy, "f").isEndpointConnected(endpointId)) {
+            return __classPrivateFieldGet$8(this, _ChannelProvider_strategy, "f").send(endpointId, action, payload);
+        }
+        return Promise.reject(new Error(`Client connection with identity uuid: ${to.uuid} / name: ${to.name} / endpointId: ${endpointId} no longer connected.`));
+    }
+    async processConnection(senderId, payload) {
+        __classPrivateFieldGet$8(this, _ChannelProvider_connections, "f").push(senderId);
+        return this.connectListener(senderId, payload);
+    }
+    /**
+     * Publish an action and payload to every connected client.
+     * Synchronously returns an array of promises for each action (see dispatch).
+     *
+     * @param action
+     * @param payload
+     *
+     * @example
+     * ```js
+     * (async ()=> {
+     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');
+     *
+     *     await provider.register('provider-action', async (payload, identity) => {
+     *         console.log(payload, identity);
+     *         return await Promise.all(provider.publish('client-action', { message: 'Broadcast from provider'}));
+     *     });
+     * })();
+     * ```
+     */
+    publish(action, payload) {
+        return this.connections.map((to) => __classPrivateFieldGet$8(this, _ChannelProvider_strategy, "f").send(to.endpointId, action, payload));
+    }
+    /**
+     * Register a listener that is called on every new client connection.
+     *
+     * @remarks It is passed the identity of the connecting client and a payload if it was provided to Channel.connect.
+     * If you wish to reject the connection, throw an error. Be sure to synchronously provide an onConnection upon receipt of
+     * the channelProvider to ensure all potential client connections are caught by the listener.
+     *
+     * Because multiple clients can exist at the same `name` and `uuid`, in order to distinguish between individual clients,
+     * the `identity` argument in a provider's `onConnection` callback contains an `endpointId` property. When dispatching from a
+     * provider to a client, the `endpointId` property must be provided in order to send an action to a specific client.
+     *
+     * @example
+     * ```js
+     * (async ()=> {
+     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');
+     *
+     *     provider.onConnection(identity => {
+     *         console.log('Client connected', identity);
+     *     });
+     * })();
+     * ```
+     *
+     * Reject connection:
+     * ```js
+     * (async ()=> {
+     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');
+     *
+     *     provider.onConnection(identity => {
+     *         throw new Error('Connection Rejected');
+     *     });
+     * })();
+     * ```
+     * @param listener
+     */
+    onConnection(listener) {
+        this.connectListener = listener;
+    }
+    /**
+     * Register a listener that is called on client disconnection. It is passed the disconnection event of the disconnecting
+     * client.
+     *
+     * @param listener
+     *
+     * @example
+     *
+     * ```js
+     * (async ()=> {
+     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');
+     *
+     *     await provider.onDisconnection(evt => {
+     *         console.log('Client disconnected', `uuid: ${evt.uuid}, name: ${evt.name}`);
+     *     });
+     * })();
+     * ```
+     */
+    onDisconnection(listener) {
+        this.disconnectListener = listener;
+    }
+    /**
+     * Destroy the channel, raises `disconnected` events on all connected channel clients.
+     *
+     * @example
+     *
+     * ```js
+     * (async ()=> {
+     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');
+     *
+     *     await provider.destroy();
+     * })();
+     * ```
+     */
+    async destroy() {
+        const protectedObj = __classPrivateFieldGet$8(this, _ChannelProvider_protectedObj, "f");
+        protectedObj.providerIdentity;
+        __classPrivateFieldSet$6(this, _ChannelProvider_connections, [], "f");
+        await protectedObj.close();
+        __classPrivateFieldGet$8(this, _ChannelProvider_close, "f").call(this);
+    }
+    /**
+     * Returns an array with info on every Client connected to the Provider
+     *
+     * @example
+     *
+     * ```js
+     * const provider = await fin.InterApplicationBus.Channel.create('openfin');
+     * const client = await fin.InterApplicationBus.Channel.connect('openfin');
+     * const clientInfo = await provider.getAllClientInfo();
+     *
+     * console.log(clientInfo);
+     *
+     * // [
+     * //    {
+     * //        "uuid": "openfin",
+     * //        "name": "openfin-view",
+     * //        "endpointId": "6d4c7ca8-4a74-4634-87f8-760558229613",
+     * //        "entityType": "view",
+     * //        "url": "https://openfin.co"
+     * //    },
+     * //    {
+     * //        "uuid": "openfin2",
+     * //        "name": "openfin-view2",
+     * //        "endpointId": "4z5d8ab9-2b81-3691-91ex-142179382511",
+     * //        "entityType": "view",
+     * //        "url": "https://example.com"
+     * //    }
+     * //]
+     * ```
+     */
+    async getAllClientInfo() {
+        return this.connections.map((clientInfo) => {
+            const { uuid, name, endpointId, entityType, connectionUrl } = clientInfo;
+            return { uuid, name, endpointId, entityType, connectionUrl };
+        });
+    }
+    checkForClientConnection(clientIdentity) {
+        if (!this.isClientConnected(clientIdentity)) {
+            throw new Error(`This action was sent from a client that is not connected to the provider.
+                    Client Identity: {uuid: ${clientIdentity.uuid}, name: ${clientIdentity.name}, endpointId: ${clientIdentity.endpointId}}`);
+        }
+    }
+    isClientConnected(clientIdentity) {
+        if (ChannelProvider.clientIdentityIncludesEndpointId(clientIdentity)) {
+            return this.connections.some((identity) => {
+                return (
+                // Might be redundant to check for uuid and name here after we get an endpointId match, but just in case
+                identity.endpointId === clientIdentity.endpointId &&
+                    identity.uuid === clientIdentity.uuid &&
+                    identity.name === clientIdentity.name);
+            });
+        }
+        return this.isLegacyClientConnected(clientIdentity);
+    }
+    isLegacyClientConnected(clientIdentity) {
+        return this.connections.some((identity) => {
+            return identity.uuid === clientIdentity.uuid && identity.name === clientIdentity.name;
+        });
+    }
+    handleMultiRuntimeLegacyClient(senderIdentity) {
+        if (!this.isLegacyClientConnected(senderIdentity)) {
+            throw new Error(`This action was sent from a client that is not connected to the provider. Client Identity:
+                    {uuid: ${senderIdentity.uuid}, name: ${senderIdentity.name}, endpointId: ${senderIdentity.endpointId}}`);
+        }
+    }
+    getEndpointIdForOpenFinId(clientIdentity, action) {
+        const matchingConnections = this.connections.filter((c) => c.name === clientIdentity.name && c.uuid === clientIdentity.uuid);
+        if (matchingConnections.length >= 2) {
+            const protectedObj = __classPrivateFieldGet$8(this, _ChannelProvider_protectedObj, "f");
+            const { uuid, name } = clientIdentity;
+            const providerUuid = protectedObj?.providerIdentity.uuid;
+            const providerName = protectedObj?.providerIdentity.name;
+            // eslint-disable-next-line no-console
+            console.warn(`WARNING: Dispatch call may have unintended results. The "to" argument of your dispatch call is missing the
+                "endpointId" parameter. The identity you are dispatching to ({uuid: ${uuid}, name: ${name}})
+                has multiple channelClients for this channel. Your dispatched action: (${action}) from the provider:
+                ({uuid: ${providerUuid}, name: ${providerName}}) will only be processed by the most recently-created client.`);
+        }
+        // Pop to return the most recently created endpointId.
+        return matchingConnections.pop()?.endpointId;
+    }
+    // eslint-disable-next-line class-methods-use-this
+    static clientIdentityIncludesEndpointId(subscriptionIdentity) {
+        return subscriptionIdentity.endpointId !== undefined;
+    }
+    // eslint-disable-next-line class-methods-use-this
+    static clientIsMultiRuntime(subscriptionIdentity) {
+        return subscriptionIdentity.runtimeUuid !== undefined;
+    }
+    static async wireClose(wire, channelName) {
+        await wire.sendAction('destroy-channel', { channelName });
+    }
+}
+provider.ChannelProvider = ChannelProvider;
+_ChannelProvider_connections = new WeakMap(), _ChannelProvider_protectedObj = new WeakMap(), _ChannelProvider_strategy = new WeakMap(), _ChannelProvider_removeEndpoint = new WeakMap(), _ChannelProvider_close = new WeakMap();
+// The following line should be changed following a typescript update.
+// static #removalMap = new WeakMap();
+ChannelProvider.removalMap = new WeakMap();
+
+var messageReceiver = {};
+
+Object.defineProperty(messageReceiver, "__esModule", { value: true });
+messageReceiver.MessageReceiver = void 0;
+const client_1$1 = client;
+const base_1$g = base;
+/*
+This is a singleton (per fin object) tasked with routing messages coming off the ipc to the correct endpoint.
+It needs to be a singleton because there can only be one per wire. It tracks both clients and providers' processAction passed in via the strategy.
+If functionality is not about receiving messages, it does not belong here.
+*/
+class MessageReceiver extends base_1$g.Base {
+    constructor(wire) {
+        super(wire);
+        this.onmessage = (msg) => {
+            if (msg.action === 'process-channel-message') {
+                this.processChannelMessage(msg);
+                return true;
+            }
+            return false;
+        };
+        this.endpointMap = new Map();
+        this.latestEndpointIdByChannelId = new Map();
+        wire.registerMessageHandler(this.onmessage.bind(this));
+    }
+    async processChannelMessage(msg) {
+        const { senderIdentity, providerIdentity, action, ackToSender, payload, intendedTargetIdentity } = msg.payload;
+        const key = intendedTargetIdentity.channelId ?? // The recipient is a provider
+            intendedTargetIdentity.endpointId ?? // The recipient is a client
+            this.latestEndpointIdByChannelId.get(providerIdentity.channelId); // No endpointId was passed, make best attempt
+        const handler = this.endpointMap.get(key);
+        if (!handler) {
+            ackToSender.payload.success = false;
+            ackToSender.payload.reason = `Client connection with identity uuid: ${this.wire.me.uuid} / name: ${this.wire.me.name} / endpointId: ${key} no longer connected.`;
+            return this.wire.sendRaw(ackToSender);
+        }
+        try {
+            const res = await handler(action, payload, senderIdentity);
+            ackToSender.payload.payload = ackToSender.payload.payload || {};
+            ackToSender.payload.payload.result = res;
+            return this.wire.sendRaw(ackToSender);
+        }
+        catch (e) {
+            ackToSender.payload.success = false;
+            ackToSender.payload.reason = e.message;
+            return this.wire.sendRaw(ackToSender);
+        }
+    }
+    addEndpoint(handler, channelId, endpointId) {
+        this.endpointMap.set(endpointId, handler);
+        // Providers have the same endpointId and channelId.
+        // This is only used when clients are receiving messages from providers, so we shouldn't save provider endpointId here.
+        if (channelId !== endpointId) {
+            this.latestEndpointIdByChannelId.set(channelId, endpointId);
+        }
+    }
+    removeEndpoint(channelId, endpointId) {
+        this.endpointMap.delete(endpointId);
+        if (this.latestEndpointIdByChannelId.get(channelId) === endpointId) {
+            this.latestEndpointIdByChannelId.delete(channelId);
+        }
+    }
+    checkForPreviousClientConnection(channelId) {
+        const endpointIdFromPreviousConnection = this.latestEndpointIdByChannelId.get(channelId);
+        if (endpointIdFromPreviousConnection) {
+            // Not convinced by this way of doing things, but pushing up for now.
+            client_1$1.ChannelClient.closeChannelByEndpointId(endpointIdFromPreviousConnection);
+            // eslint-disable-next-line no-console
+            console.warn('You have created a second connection to an older provider. First connection has been removed from the clientMap');
+            // eslint-disable-next-line no-console
+            console.warn('If the provider calls publish(), you may receive multiple messages.');
+        }
+    }
+}
+messageReceiver.MessageReceiver = MessageReceiver;
+
+var protocolManager = {};
+
+Object.defineProperty(protocolManager, "__esModule", { value: true });
+protocolManager.ProtocolManager = void 0;
+/*
+This should be agnostic of any actual openfin code to be unit testable.
+Dependencies on the actual srategies should be handled in ConnectionManager
+*/
+class ProtocolManager {
+    // eslint-disable-next-line no-useless-constructor
+    constructor(ProtocolsInPreferenceOrder) {
+        this.ProtocolsInPreferenceOrder = ProtocolsInPreferenceOrder;
+        this.DefaultClientProtocols = ['classic'];
+        this.DefaultProviderProtocols = ['classic'];
+        this.getClientProtocols = (protocols) => {
+            const supported = protocols
+                ? this.ProtocolsInPreferenceOrder.filter((x) => protocols.includes(x))
+                : this.DefaultClientProtocols;
+            if (!supported.length) {
+                throw new Error(`No valid protocols were passed in. Accepted values are: ${this.ProtocolsInPreferenceOrder.join(', ')}.`);
+            }
+            return supported;
+        };
+        this.getProviderProtocols = (protocols) => {
+            const supported = protocols
+                ? this.ProtocolsInPreferenceOrder.filter((x) => protocols.includes(x))
+                : this.DefaultProviderProtocols;
+            if (!supported.length) {
+                throw new Error(`No valid protocols were passed in. Accepted values are: ${this.ProtocolsInPreferenceOrder.join(', ')}.`);
+            }
+            return supported;
+        };
+        this.getCompatibleProtocols = (providerProtocols, clientOffer) => {
+            const supported = clientOffer.supportedProtocols.filter((clientProtocol) => providerProtocols.some((providerProtocol) => providerProtocol.type === clientProtocol.type &&
+                clientProtocol.version >= providerProtocol.minimumVersion &&
+                providerProtocol.version >= (clientProtocol.minimumVersion ?? 0)));
+            return supported.slice(0, clientOffer.maxProtocols);
+        };
+    }
+}
+protocolManager.ProtocolManager = ProtocolManager;
+
+var strategy = {};
+
+Object.defineProperty(strategy, "__esModule", { value: true });
+class CombinedStrategy {
+    // Making this a static method because the constructor can't be typed.
+    // Otherwise it will error when calling addEndpoint but I'd rather the whole instance be typed as never.
+    static combine(a, b) {
+        return new CombinedStrategy(a, b);
+    }
+    // eslint-disable-next-line no-useless-constructor
+    constructor(primary, secondary) {
+        this.primary = primary;
+        this.secondary = secondary;
+    }
+    onEndpointDisconnect(endpointId, listener) {
+        this.primary.onEndpointDisconnect(endpointId, () => {
+            if (!this.secondary.isEndpointConnected(endpointId)) {
+                listener();
+            }
+        });
+        this.secondary.onEndpointDisconnect(endpointId, () => {
+            if (!this.primary.isEndpointConnected(endpointId)) {
+                listener();
+            }
+        });
+    }
+    isValidEndpointPayload(payload) {
+        return this.primary.isValidEndpointPayload(payload) || this.secondary.isValidEndpointPayload(payload);
+    }
+    async closeEndpoint(endpointId) {
+        await this.primary.closeEndpoint(endpointId);
+        await this.secondary.closeEndpoint(endpointId);
+    }
+    isEndpointConnected(endpoint) {
+        return this.primary.isEndpointConnected(endpoint) || this.secondary.isEndpointConnected(endpoint);
+    }
+    async addEndpoint(endpoint, payload) {
+        if (this.primary.isValidEndpointPayload(payload)) {
+            await this.primary.addEndpoint(endpoint, payload);
+        }
+        if (this.secondary.isValidEndpointPayload(payload)) {
+            await this.secondary.addEndpoint(endpoint, payload);
+        }
+    }
+    receive(listener) {
+        this.primary.receive(listener);
+        this.secondary.receive(listener);
+    }
+    send(endpointId, action, payload) {
+        if (this.primary.isEndpointConnected(endpointId)) {
+            return this.primary.send(endpointId, action, payload);
+        }
+        return this.secondary.send(endpointId, action, payload);
+    }
+    async close() {
+        await Promise.all([this.primary.close(), this.secondary.close()]);
+    }
+}
+strategy.default = CombinedStrategy;
+
+var __classPrivateFieldSet$5 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet$7 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault$1 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _ConnectionManager_messageReceiver, _ConnectionManager_rtcConnectionManager;
+Object.defineProperty(connectionManager, "__esModule", { value: true });
+connectionManager.ConnectionManager = void 0;
+const exhaustive_1 = exhaustive;
+const base_1$f = base;
+const strategy_1 = strategy$3;
+const strategy_2 = strategy$2;
+const ice_manager_1 = iceManager;
+const provider_1$1 = provider;
+const message_receiver_1 = messageReceiver;
+const protocol_manager_1 = protocolManager;
+const strategy_3 = __importDefault$1(strategy);
+class ConnectionManager extends base_1$f.Base {
+    static getProtocolOptionsFromStrings(protocols) {
+        return protocols.map((protocol) => {
+            switch (protocol) {
+                case 'rtc':
+                    return strategy_2.RTCInfo;
+                case 'classic':
+                    return strategy_1.ClassicInfo;
+                default:
+                    return (0, exhaustive_1.exhaustiveCheck)(protocol, ['rtc', 'classic']);
+            }
+        });
+    }
+    constructor(wire) {
+        super(wire);
+        _ConnectionManager_messageReceiver.set(this, void 0);
+        _ConnectionManager_rtcConnectionManager.set(this, void 0);
+        this.removeChannelFromProviderMap = (channelId) => {
+            this.providerMap.delete(channelId);
+        };
+        this.onmessage = (msg) => {
+            if (msg.action === 'process-channel-connection') {
+                this.processChannelConnection(msg);
+                return true;
+            }
+            return false;
+        };
+        this.providerMap = new Map();
+        this.protocolManager = new protocol_manager_1.ProtocolManager(this.wire.environment.type === 'node' ? ['classic'] : ['rtc', 'classic']);
+        __classPrivateFieldSet$5(this, _ConnectionManager_messageReceiver, new message_receiver_1.MessageReceiver(wire), "f");
+        __classPrivateFieldSet$5(this, _ConnectionManager_rtcConnectionManager, new ice_manager_1.RTCICEManager(wire), "f");
+        wire.registerMessageHandler(this.onmessage.bind(this));
+    }
+    createProvider(options, providerIdentity) {
+        const opts = Object.assign(this.wire.environment.getDefaultChannelOptions().create, options || {});
+        const protocols = this.protocolManager.getProviderProtocols(opts?.protocols);
+        const createSingleStrategy = (stratType) => {
+            switch (stratType) {
+                case 'rtc':
+                    return new strategy_2.RTCStrategy();
+                case 'classic':
+                    return new strategy_1.ClassicStrategy(this.wire, __classPrivateFieldGet$7(this, _ConnectionManager_messageReceiver, "f"), 
+                    // Providers do not have an endpointId, use channelId as endpointId in the strategy.
+                    providerIdentity.channelId, providerIdentity);
+                default:
+                    return (0, exhaustive_1.exhaustiveCheck)(stratType, ['rtc', 'classic']);
+            }
+        };
+        const strategies = protocols.map(createSingleStrategy);
+        let strategy;
+        if (strategies.length === 2) {
+            const [a, b] = strategies;
+            strategy = strategy_3.default.combine(a, b);
+        }
+        else if (strategies.length === 1) {
+            [strategy] = strategies;
+        }
+        else {
+            // Should be impossible.
+            throw new Error('failed to combine strategies');
+        }
+        const channel = new provider_1$1.ChannelProvider(providerIdentity, () => provider_1$1.ChannelProvider.wireClose(this.wire, providerIdentity.channelName), strategy);
+        const key = providerIdentity.channelId;
+        this.providerMap.set(key, {
+            provider: channel,
+            strategy,
+            supportedProtocols: ConnectionManager.getProtocolOptionsFromStrings(protocols)
+        });
+        provider_1$1.ChannelProvider.setProviderRemoval(channel, this.removeChannelFromProviderMap.bind(this));
+        return channel;
+    }
+    async createClientOffer(options) {
+        const protocols = this.protocolManager.getClientProtocols(options?.protocols);
+        let rtcPacket;
+        const supportedProtocols = await Promise.all(protocols.map(async (type) => {
+            switch (type) {
+                case 'rtc': {
+                    const { rtcClient, channels, offer, rtcConnectionId, channelsOpened } = await __classPrivateFieldGet$7(this, _ConnectionManager_rtcConnectionManager, "f").startClientOffer();
+                    rtcPacket = { rtcClient, channels, channelsOpened };
+                    return {
+                        type: 'rtc',
+                        version: strategy_2.RTCInfo.version,
+                        payload: { offer, rtcConnectionId }
+                    };
+                }
+                case 'classic':
+                    return { type: 'classic', version: strategy_1.ClassicInfo.version };
+                default:
+                    return (0, exhaustive_1.exhaustiveCheck)(type, ['rtc', 'classic']);
+            }
+        }));
+        return {
+            offer: {
+                supportedProtocols,
+                maxProtocols: 2
+            },
+            rtc: rtcPacket
+        };
+    }
+    async createClientStrategy(rtcPacket, routingInfo) {
+        if (!routingInfo.endpointId) {
+            routingInfo.endpointId = this.wire.environment.getNextMessageId();
+            // For New Clients connecting to Old Providers. To prevent multi-dispatching and publishing, we delete previously-connected
+            // clients that are in the same context as the newly-connected client.
+            __classPrivateFieldGet$7(this, _ConnectionManager_messageReceiver, "f").checkForPreviousClientConnection(routingInfo.channelId);
+        }
+        const answer = routingInfo.answer ?? {
+            supportedProtocols: [{ type: 'classic', version: 1 }]
+        };
+        const createStrategyFromAnswer = async (protocol) => {
+            if (protocol.type === 'rtc' && rtcPacket) {
+                await __classPrivateFieldGet$7(this, _ConnectionManager_rtcConnectionManager, "f").finishClientOffer(rtcPacket.rtcClient, protocol.payload.answer, rtcPacket.channelsOpened);
+                return new strategy_2.RTCStrategy();
+            }
+            if (protocol.type === 'classic') {
+                return new strategy_1.ClassicStrategy(this.wire, __classPrivateFieldGet$7(this, _ConnectionManager_messageReceiver, "f"), routingInfo.endpointId, routingInfo);
+            }
+            return null;
+        };
+        const allProtocols = (await Promise.all(answer.supportedProtocols.map(createStrategyFromAnswer))).filter((x) => x !== null);
+        // Clean up logic if provider didn't support rtc.
+        if (rtcPacket && !allProtocols.some((x) => x instanceof strategy_2.RTCStrategy)) {
+            if (rtcPacket) {
+                rtcPacket.rtcClient.close();
+            }
+        }
+        let strategy;
+        if (allProtocols.length >= 2) {
+            strategy = strategy_3.default.combine(allProtocols[0], allProtocols[1]);
+        }
+        else if (allProtocols.length) {
+            [strategy] = allProtocols;
+        }
+        else {
+            // Should be impossible.
+            throw new Error('No compatible protocols');
+        }
+        // as casting rtcPacket because we won't have an rtcStrategy if rtcPacket is undefined;
+        const endpointPayload = { endpointIdentity: routingInfo, rtc: rtcPacket };
+        strategy.addEndpoint(routingInfo.channelId, endpointPayload);
+        return strategy;
+    }
+    async processChannelConnection(msg) {
+        const { clientIdentity, providerIdentity, ackToSender, payload, offer: clientOffer } = msg.payload;
+        if (!clientIdentity.endpointId) {
+            // Should be polyfilled by core but not in cases of node connecting to an old runtime.
+            clientIdentity.endpointId = this.wire.environment.getNextMessageId();
+            clientIdentity.isLocalEndpointId = true;
+        }
+        else {
+            clientIdentity.isLocalEndpointId = false;
+        }
+        const key = providerIdentity.channelId;
+        const bus = this.providerMap.get(key);
+        if (!bus) {
+            ackToSender.payload.success = false;
+            ackToSender.payload.reason = `Channel "${providerIdentity.channelName}" has been destroyed.`;
+            return this.wire.sendRaw(ackToSender);
+        }
+        const { provider, strategy, supportedProtocols } = bus;
+        try {
+            if (!(provider instanceof provider_1$1.ChannelProvider)) {
+                throw Error('Cannot connect to a channel client');
+            }
+            const offer = clientOffer ?? {
+                supportedProtocols: [{ type: 'classic', version: 1 }],
+                maxProtocols: 1
+            };
+            const overlappingProtocols = this.protocolManager.getCompatibleProtocols(supportedProtocols, offer);
+            if (!overlappingProtocols.length) {
+                throw new Error('This provider does not support any of the offered protocols.');
+            }
+            const res = await provider.processConnection(clientIdentity, payload);
+            ackToSender.payload.payload = ackToSender.payload.payload || {};
+            // Loop through all supported protocols and accumulate them into the answer
+            // addEndpoint is tricky but we need to wait for channel resolution before adding the endpoint.
+            let clientAnswer = {
+                supportedProtocols: [],
+                endpointPayloadPromise: Promise.resolve({ endpointIdentity: clientIdentity })
+            };
+            clientAnswer = await overlappingProtocols.reduce(async (accumP, protocolToUse) => {
+                const answer = await accumP;
+                if (protocolToUse.type === 'rtc') {
+                    const { answer: rtcAnswer, rtcClient, channels } = await __classPrivateFieldGet$7(this, _ConnectionManager_rtcConnectionManager, "f").createProviderAnswer(protocolToUse.payload.rtcConnectionId, protocolToUse.payload.offer);
+                    answer.supportedProtocols.push({
+                        type: 'rtc',
+                        version: strategy_2.RTCInfo.version,
+                        payload: {
+                            answer: rtcAnswer
+                        }
+                    });
+                    answer.endpointPayloadPromise = answer.endpointPayloadPromise.then((endpointPayload) => channels.then((resolvedChannels) => {
+                        return {
+                            ...endpointPayload,
+                            rtc: {
+                                rtcClient,
+                                channels: resolvedChannels
+                            }
+                        };
+                    }));
+                }
+                else {
+                    answer.supportedProtocols.push({ type: 'classic', version: strategy_1.ClassicInfo.version });
+                }
+                return answer;
+            }, Promise.resolve(clientAnswer));
+            // Need to as cast here.
+            clientAnswer.endpointPayloadPromise.then((endpointPayload) => strategy.addEndpoint(clientIdentity.endpointId, endpointPayload));
+            ackToSender.payload.payload.result = res;
+            ackToSender.payload.payload.answer = clientAnswer;
+            return this.wire.sendRaw(ackToSender);
+        }
+        catch (e) {
+            ackToSender.payload.success = false;
+            ackToSender.payload.reason = e.message;
+            return this.wire.sendRaw(ackToSender);
+        }
+    }
+}
+connectionManager.ConnectionManager = ConnectionManager;
+_ConnectionManager_messageReceiver = new WeakMap(), _ConnectionManager_rtcConnectionManager = new WeakMap();
+
+/**
+ * Entry points for the `Channel` subset of the `InterApplicationBus` API (`fin.InterApplicationBus.Channel`).
+ *
+ * * {@link Channel} contains static members of the `Channel` API, accessible through `fin.InterApplicationBus.Channel`.
+ * * {@link OpenFin.ChannelClient} describes a client of a channel, e.g. as returned by `fin.InterApplicationBus.Channel.connect`.
+ * * {@link OpenFin.ChannelProvider} describes a provider of a channel, e.g. as returned by `fin.InterApplicationBus.Channel.create`.
+ *
+ * @packageDocumentation
+ */
+var __classPrivateFieldSet$4 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet$6 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Channel_connectionManager, _Channel_internalEmitter, _Channel_readyToConnect;
+Object.defineProperty(channel$1, "__esModule", { value: true });
+channel$1.Channel = void 0;
+/* eslint-disable no-console */
+const events_1$5 = require$$0;
+const lazy_1$1 = lazy;
+const base_1$e = base;
+const client_1 = client;
+const connection_manager_1 = connectionManager;
+const provider_1 = provider;
+function retryDelay(count) {
+    const interval = 500; // base delay
+    const steps = 10; // How many retries to do before incrementing the delay
+    const base = 2; // How much to multiply the previous delay by
+    const max = 30000; // max delay
+    const step = Math.floor(count / steps);
+    const delay = Math.min(max, interval * base ** step);
+    return new Promise((resolve) => {
+        setTimeout(() => {
+            resolve(false);
+        }, delay);
+    });
+}
+/**
+ * The Channel API allows an OpenFin application to create a channel as a {@link ChannelProvider ChannelProvider},
+ * or connect to a channel as a {@link ChannelClient ChannelClient}.
+ * @remarks The "handshake" between the communication partners is
+ * simplified when using a channel.  A request to connect to a channel as a client will return a promise that resolves if/when the channel has been created. Both the
+ * provider and client can dispatch actions that have been registered on their opposites, and dispatch returns a promise that resolves with a payload from the other
+ * communication participant. There can be only one provider per channel, but many clients.  Version `9.61.35.*` or later is required for both communication partners.
+ *
+ * Asynchronous Methods:
+ *  * {@link Channel.create create(channelName, options)}
+ *  * {@link Channel.connect connect(channelName, options)}
+ *  * {@link Channel.onChannelConnect onChannelConnect(listener)}
+ *  * {@link Channel.onChannelDisconnect onChannelDisconnect(listener)}
+ */
+class Channel extends base_1$e.EmitterBase {
+    /**
+     * @internal
+     */
+    constructor(wire) {
+        super(wire, 'channel');
+        _Channel_connectionManager.set(this, void 0);
+        _Channel_internalEmitter.set(this, new events_1$5.EventEmitter());
+        // OpenFin API has not been injected at construction time, *must* wait for API to be ready.
+        _Channel_readyToConnect.set(this, new lazy_1$1.AsyncRetryableLazy(async () => {
+            await Promise.all([
+                this.on('disconnected', (eventPayload) => {
+                    client_1.ChannelClient.handleProviderDisconnect(eventPayload);
+                }),
+                this.on('connected', (...args) => {
+                    __classPrivateFieldGet$6(this, _Channel_internalEmitter, "f").emit('connected', ...args);
+                })
+            ]).catch(() => new Error('error setting up channel connection listeners'));
+        }));
+        __classPrivateFieldSet$4(this, _Channel_connectionManager, new connection_manager_1.ConnectionManager(wire), "f");
+    }
+    /**
+     *
+     * @internal
+     */
+    async getAllChannels() {
+        return this.wire.sendAction('get-all-channels').then(({ payload }) => payload.data);
+    }
+    /**
+     * Listens for channel connections.
+     *
+     * @param listener - callback to execute.
+     *
+     * @example
+     *
+     * ```js
+     * const listener = (channelPayload) => console.log(channelPayload); // see return value below
+     *
+     * fin.InterApplicationBus.Channel.onChannelConnect(listener);
+     *
+     * // example shape
+     * {
+     *     "topic": "channel",
+     *     "type": "connected",
+     *     "uuid": "OpenfinPOC",
+     *     "name": "OpenfinPOC",
+     *     "channelName": "counter",
+     *     "channelId": "OpenfinPOC/OpenfinPOC/counter"
+     * }
+     *
+     * ```
+     */
+    async onChannelConnect(listener) {
+        await this.on('connected', listener);
+    }
+    /**
+     * Listen for channel disconnections.
+     *
+     * @param listener - callback to execute.
+     *
+     * @example
+     *
+     * ```js
+     * const listener = (channelPayload) => console.log(channelPayload); // see return value below
+     *
+     * fin.InterApplicationBus.Channel.onChannelDisconnect(listener);
+     *
+     * // example shape
+     * {
+     *     "topic": "channel",
+     *     "type": "disconnected",
+     *     "uuid": "OpenfinPOC",
+     *     "name": "OpenfinPOC",
+     *     "channelName": "counter",
+     *     "channelId": "OpenfinPOC/OpenfinPOC/counter"
+     * }
+     *
+     * ```
+     */
+    async onChannelDisconnect(listener) {
+        await this.on('disconnected', listener);
+    }
+    async safeConnect(channelName, shouldWait, connectPayload) {
+        const retryInfo = { count: 0 };
+        /* eslint-disable no-await-in-loop, no-constant-condition */
+        do {
+            // setup a listener and a connected promise to await in case we connect before the channel is ready
+            let connectedListener = () => undefined;
+            const connectedPromise = new Promise((resolve) => {
+                connectedListener = (payload) => {
+                    if (channelName === payload.channelName) {
+                        resolve(true);
+                    }
+                };
+                __classPrivateFieldGet$6(this, _Channel_internalEmitter, "f").on('connected', connectedListener);
+            });
+            try {
+                if (retryInfo.count > 0) {
+                    // Wait before retrying
+                    // Delay returns false connectedPromise returns true so we can know if a retry is due to connected event
+                    retryInfo.gotConnectedEvent = await Promise.race([retryDelay(retryInfo.count), connectedPromise]);
+                    const result = await this.wire.sendAction('connect-to-channel', { ...connectPayload, retryInfo });
+                    // log only if there was a retry
+                    console.log(`Successfully connected to channelName: ${channelName}`);
+                    return result.payload.data;
+                }
+                // Send retryInfo to the core for debug log inclusion
+                const sentMessagePromise = this.wire.sendAction('connect-to-channel', connectPayload);
+                // Save messageId from the first connection attempt
+                retryInfo.originalMessageId = sentMessagePromise.messageId;
+                const result = await sentMessagePromise;
+                return result.payload.data;
+            }
+            catch (error) {
+                if (!error.message.includes('internal-nack')) {
+                    // Not an internal nack, break the loop
+                    throw error;
+                }
+                if (shouldWait && retryInfo.count === 0) {
+                    // start waiting on the next iteration, warn the user
+                    console.warn(`No channel found for channelName: ${channelName}. Waiting for connection...`);
+                }
+            }
+            finally {
+                retryInfo.count += 1;
+                // in case of other errors, remove our listener
+                __classPrivateFieldGet$6(this, _Channel_internalEmitter, "f").removeListener('connected', connectedListener);
+            }
+        } while (shouldWait); // If we're waiting we retry the above loop
+        // Should wait was false, no channel was found.
+        throw new Error(`No channel found for channelName: ${channelName}.`);
+        /* eslint-enable no-await-in-loop, no-constant-condition */
+    }
+    /**
+     * Connect to a channel. If you wish to send a payload to the provider, add a payload property to the options argument.
+     * EXPERIMENTAL: pass { protocols: ['rtc'] } as options to opt-in to High Throughput Channels.
+     *
+     * @param channelName - Name of the target channel.
+     * @param options - Connection options.
+     * @returns Returns a promise that resolves with an instance of {@link ChannelClient ChannelClient}.
+     *
+     * @remarks The connection request will be routed to the channelProvider if/when the channel is created.  If the connect
+     * request is sent prior to creation, the promise will not resolve or reject until the channel is created by a channelProvider
+     * (whether or not to wait for creation is configurable in the connectOptions).
+     *
+     * The connect call returns a promise that will resolve with a channelClient bus if accepted by the channelProvider, or reject if
+     * the channelProvider throws an error to reject the connection. This bus can communicate with the Provider, but not to other
+     * clients on the channel. Using the bus, the channelClient can register actions and middleware. Channel lifecycle can also be
+     * handled with an onDisconnection listener.
+     *
+     * @example
+     *
+     * ```js
+     * async function makeClient(channelName) {
+     *    // A payload can be sent along with channel connection requests to help with authentication
+     *    const connectPayload = { payload: 'token' };
+     *
+     *    // If the channel has been created this request will be sent to the provider.  If not, the
+     *    // promise will not be resolved or rejected until the channel has been created.
+     *    const clientBus = await fin.InterApplicationBus.Channel.connect(channelName, connectPayload);
+     *
+     *    clientBus.onDisconnection(channelInfo => {
+     *        // handle the channel lifecycle here - we can connect again which will return a promise
+     *        // that will resolve if/when the channel is re-created.
+     *        makeClient(channelInfo.channelName);
+     *    })
+     *
+     *    clientBus.register('topic', (payload, identity) => {
+     *        // register a callback for a topic to which the channel provider can dispatch an action
+     *        console.log('Action dispatched by provider: ', JSON.stringify(identity));
+     *        console.log('Payload sent in dispatch: ', JSON.stringify(payload));
+     *        return {
+     *            echo: payload
+     *        };
+     *    });
+     * }
+     *
+     * makeClient('channelName')
+     * .then(() => console.log('Connected'))
+     * .catch(console.error);
+     * ```
+     */
+    async connect(channelName, options = {}) {
+        // Make sure we don't connect before listeners are set up
+        // This also errors if we're not in OpenFin, ensuring we don't run unnecessary code
+        await __classPrivateFieldGet$6(this, _Channel_readyToConnect, "f").getValue();
+        if (!channelName || typeof channelName !== 'string') {
+            throw new Error('Please provide a channelName string to connect to a channel.');
+        }
+        const opts = { wait: true, ...this.wire.environment.getDefaultChannelOptions().connect, ...options };
+        const { offer, rtc: rtcPacket } = await __classPrivateFieldGet$6(this, _Channel_connectionManager, "f").createClientOffer(opts);
+        let connectionUrl;
+        if (this.fin.me.isFrame || this.fin.me.isView || this.fin.me.isWindow) {
+            connectionUrl = (await this.fin.me.getInfo()).url;
+        }
+        const connectPayload = {
+            channelName,
+            ...opts,
+            offer,
+            connectionUrl
+        };
+        const routingInfo = await this.safeConnect(channelName, opts.wait, connectPayload);
+        const strategy = await __classPrivateFieldGet$6(this, _Channel_connectionManager, "f").createClientStrategy(rtcPacket, routingInfo);
+        const channel = new client_1.ChannelClient(routingInfo, () => client_1.ChannelClient.wireClose(this.wire, routingInfo, routingInfo.endpointId), strategy);
+        // It is the client's responsibility to handle endpoint disconnection to the provider.
+        // If the endpoint dies, the client will force a disconnection through the core.
+        // The provider does not care about endpoint disconnection.
+        strategy.onEndpointDisconnect(routingInfo.channelId, async () => {
+            try {
+                await channel.sendDisconnectAction();
+            }
+            catch (error) {
+                console.warn(`Something went wrong during disconnect for client with uuid: ${routingInfo.uuid} / name: ${routingInfo.name} / endpointId: ${routingInfo.endpointId}.`);
+            }
+            finally {
+                client_1.ChannelClient.handleProviderDisconnect(routingInfo);
+            }
+        });
+        return channel;
+    }
+    /**
+     * Create a new channel.
+     * You must provide a unique channelName. If a channelName is not provided, or it is not unique, the creation will fail.
+     * EXPERIMENTAL: pass { protocols: ['rtc'] } as options to opt-in to High Throughput Channels.
+     *
+     * @param channelName - Name of the channel to be created.
+     * @param options - Creation options.
+     * @returns Returns a promise that resolves with an instance of {@link ChannelProvider ChannelProvider}.
+     *
+     * @remarks If successful, the create method returns a promise that resolves to an instance of the channelProvider bus. The caller
+     * then becomes the “channel provider” and can use the channelProvider bus to register actions and middleware.
+     *
+     * The caller can also set an onConnection and/or onDisconnection listener that will execute on any new channel
+     * connection/disconnection attempt from a channel client. To reject a connection, simply throw an error in the
+     * onConnection listener.  The default behavior is to accept all new connections.
+     *
+     * A map of client connections is updated automatically on client connection and disconnection and saved in the
+     * [read-only] `connections` property on the channelProvider bus.  The channel will exist until the provider
+     * destroys it or disconnects by closing or destroying the context (navigating or reloading). To setup a channel
+     * as a channelProvider, call `Channel.create` with a unique channel name. A map of client connections is updated
+     * automatically on client connection and disconnection.
+     *
+     * @example
+     *
+     * ```js
+     * (async ()=> {
+     *    // entity creates a channel and becomes the channelProvider
+     *    const providerBus = await fin.InterApplicationBus.Channel.create('channelName');
+     *
+     *    providerBus.onConnection((identity, payload) => {
+     *        // can reject a connection here by throwing an error
+     *        console.log('Client connection request identity: ', JSON.stringify(identity));
+     *        console.log('Client connection request payload: ', JSON.stringify(payload));
+     *    });
+     *
+     *    providerBus.register('topic', (payload, identity) => {
+     *        // register a callback for a 'topic' to which clients can dispatch an action
+     *        console.log('Action dispatched by client: ', JSON.stringify(identity));
+     *        console.log('Payload sent in dispatch: ', JSON.stringify(payload));
+     *        return {
+     *            echo: payload
+     *        };
+     *    });
+     * })();
+     * ```
+     */
+    async create(channelName, options) {
+        if (!channelName) {
+            throw new Error('Please provide a channelName to create a channel');
+        }
+        const { payload: { data: providerIdentity } } = await this.wire.sendAction('create-channel', { channelName });
+        const channel = __classPrivateFieldGet$6(this, _Channel_connectionManager, "f").createProvider(options, providerIdentity);
+        // TODO: fix typing (internal)
+        // @ts-expect-error
+        this.on('client-disconnected', (eventPayload) => {
+            if (eventPayload.channelName === channelName) {
+                provider_1.ChannelProvider.handleClientDisconnection(channel, eventPayload);
+            }
+        });
+        return channel;
+    }
+}
+channel$1.Channel = Channel;
+_Channel_connectionManager = new WeakMap(), _Channel_internalEmitter = new WeakMap(), _Channel_readyToConnect = new WeakMap();
+
+Object.defineProperty(interappbus, "__esModule", { value: true });
+interappbus.InterAppPayload = interappbus.InterApplicationBus = void 0;
+/**
+ * Entry point for the OpenFin `InterApplicationBus` API (`fin.InterApplicationBus`).
+ *
+ * * {@link InterApplicationBus} contains static members of the `InterApplicationBus` API, accessible through `fin.InterApplicationBus`.
+ *
+ * @packageDocumentation
+ */
+const events_1$4 = require$$0;
+const base_1$d = base;
+const ref_counter_1 = refCounter;
+const index_1$2 = channel$1;
+const validate_1$3 = validate;
+/**
+ * A messaging bus that allows for pub/sub messaging between different applications.
+ *
+ */
+class InterApplicationBus extends base_1$d.Base {
+    /**
+     * @internal
+     */
+    constructor(wire) {
+        super(wire);
+        this.events = {
+            subscriberAdded: 'subscriber-added',
+            subscriberRemoved: 'subscriber-removed'
+        };
+        this.refCounter = new ref_counter_1.RefCounter();
+        this.Channel = new index_1$2.Channel(wire);
+        this.emitter = new events_1$4.EventEmitter();
+        wire.registerMessageHandler(this.onmessage.bind(this));
+        this.on = this.emitter.on.bind(this.emitter);
+        this.removeAllListeners = this.emitter.removeAllListeners.bind(this.emitter);
+    }
+    /**
+     * Publishes a message to all applications running on OpenFin Runtime that
+     * are subscribed to the specified topic.
+     * @param topic The topic on which the message is sent
+     * @param message The message to be published. Can be either a primitive
+     * data type (string, number, or boolean) or composite data type (object, array)
+     * that is composed of other primitive or composite data types
+     *
+     * @example
+     * ```js
+     * fin.InterApplicationBus.publish('topic', 'hello').then(() => console.log('Published')).catch(err => console.log(err));
+     * ```
+     */
+    async publish(topic, message) {
+        await this.wire.sendAction('publish-message', {
+            topic,
+            message,
+            sourceWindowName: this.me.name
+        });
+    }
+    /**
+     * Sends a message to a specific application on a specific topic.
+     * @param destination The identity of the application to which the message is sent
+     * @param topic The topic on which the message is sent
+     * @param message The message to be sent. Can be either a primitive data
+     * type (string, number, or boolean) or composite data type (object, array) that
+     * is composed of other primitive or composite data types
+     *
+     * @example
+     * ```js
+     * fin.InterApplicationBus.send(fin.me, 'topic', 'Hello there!').then(() => console.log('Message sent')).catch(err => console.log(err));
+     * ```
+     */
+    async send(destination, topic, message) {
+        const errorMsg = (0, validate_1$3.validateIdentity)(destination);
+        if (errorMsg) {
+            throw new Error(errorMsg);
+        }
+        await this.wire.sendAction('send-message', {
+            destinationUuid: destination.uuid,
+            destinationWindowName: destination.name,
+            topic,
+            message,
+            sourceWindowName: this.me.name
+        });
+    }
+    /**
+     * Subscribes to messages from the specified application on the specified topic.
+     * @param source This object is described in the Identity in the typedef
+     * @param topic The topic on which the message is sent
+     * @param listener A function that is called when a message has
+     * been received. It is passed the message, uuid and name of the sending application.
+     * The message can be either a primitive data type (string, number, or boolean) or
+     * composite data type (object, array) that is composed of other primitive or composite
+     * data types
+     *
+     * @example
+     * ```js
+     * // subscribe to a specified application
+     * fin.InterApplicationBus.subscribe(fin.me, 'topic', sub_msg => console.log(sub_msg)).then(() => console.log('Subscribed to the specified application')).catch(err => console.log(err));
+     *
+     * // subscribe to wildcard
+     * fin.InterApplicationBus.subscribe({ uuid: '*' }, 'topic', sub_msg => console.log(sub_msg)).then(() => console.log('Subscribed to *')).catch(err => console.log(err));
+     * ```
+     */
+    subscribe(source, topic, listener) {
+        const subKey = this.createSubscriptionKey(source.uuid, source.name || '*', topic);
+        const sendSubscription = async () => {
+            await this.wire.sendAction('subscribe', {
+                sourceUuid: source.uuid,
+                sourceWindowName: source.name || '*',
+                topic,
+                destinationWindowName: this.me.name
+            });
+        };
+        const alreadySubscribed = () => {
+            return Promise.resolve();
+        };
+        this.emitter.on(subKey, listener);
+        return this.refCounter.actOnFirst(subKey, sendSubscription, alreadySubscribed);
+    }
+    /**
+     * Unsubscribes to messages from the specified application on the specified topic.
+     *
+     * @remarks If you are listening to all apps on a topic, (i.e you passed `{ uuid:'*' }` to the subscribe function)
+     * then you need to pass `{ uuid:'*' }` to unsubscribe as well. If you are listening to a specific application,
+     * (i.e you passed `{ uuid:'some_app' }` to the subscribe function) then you need to provide the same identifier to
+     * unsubscribe, unsubscribing to `*` on that same topic will not unhook your initial listener otherwise.
+     *
+     * @param source This object is described in the Identity in the typedef
+     * @param topic The topic on which the message is sent
+     * @param listener A callback previously registered with subscribe()
+     *
+     * @example
+     * ```js
+     * const listener = console.log;
+     *
+     * // If any application publishes a message on topic `foo`, our listener will be called.
+     * await fin.InterApplicationBus.subscribe({ uuid:'*' }, 'foo', listener)
+     *
+     * // When you want to unsubscribe, you need to specify the uuid of the app you'd like to
+     * // unsubscribe from (or `*`) and provide the same function you gave the subscribe function
+     * await fin.InterApplicationBus.unsubscribe({ uuid:'*' }, 'foo', listener)
+     * ```
+     */
+    unsubscribe(source, topic, listener) {
+        const sourceWindowName = source.name || '*';
+        const subKey = this.createSubscriptionKey(source.uuid, sourceWindowName, topic);
+        const sendUnsubscription = async () => {
+            await this.wire.sendAction('unsubscribe', {
+                sourceUuid: source.uuid,
+                sourceWindowName,
+                topic,
+                destinationWindowName: this.me.name
+            });
+        };
+        const dontSendUnsubscription = () => {
+            return new Promise((r) => r).then(() => undefined);
+        };
+        this.emitter.removeListener(subKey, listener);
+        return this.refCounter.actOnLast(subKey, sendUnsubscription, dontSendUnsubscription);
+    }
+    processMessage(message) {
+        const { payload: { message: payloadMessage, sourceWindowName, sourceUuid, topic } } = message;
+        const keys = [
+            this.createSubscriptionKey(sourceUuid, sourceWindowName, topic),
+            this.createSubscriptionKey(sourceUuid, '*', topic),
+            this.createSubscriptionKey('*', '*', topic)
+        ];
+        const idOfSender = { uuid: sourceUuid, name: sourceWindowName };
+        keys.forEach((key) => {
+            this.emitter.emit(key, payloadMessage, idOfSender);
+        });
+    }
+    emitSubscriverEvent(type, message) {
+        const { payload: { targetName: name, uuid, topic } } = message;
+        const payload = { name, uuid, topic };
+        this.emitter.emit(type, payload);
+    }
+    // eslint-disable-next-line class-methods-use-this
+    createSubscriptionKey(uuid, name, topic) {
+        const n = name || '*';
+        if (!(uuid && n && topic)) {
+            throw new Error('Missing uuid, name, or topic string');
+        }
+        return createKey(uuid, n, topic);
+    }
+    onmessage(message) {
+        const { action } = message;
+        switch (action) {
+            case 'process-message':
+                this.processMessage(message);
+                break;
+            case this.events.subscriberAdded:
+                this.emitSubscriverEvent(this.events.subscriberAdded, message);
+                break;
+            case this.events.subscriberRemoved:
+                this.emitSubscriverEvent(this.events.subscriberRemoved, message);
+                break;
+        }
+        return true;
+    }
+}
+interappbus.InterApplicationBus = InterApplicationBus;
+/**
+ * @internal
+ */
+class InterAppPayload {
+}
+interappbus.InterAppPayload = InterAppPayload;
+function createKey(...toHash) {
+    return toHash
+        .map((item) => {
+        return Buffer.from(`${item}`).toString('base64');
+    })
+        .join('/');
+}
+
+var clipboard = {};
+
+/**
+ * Entry point for the OpenFin `Clipboard` API (`fin.Clipboard`).
+ *
+ * * {@link Clipboard} contains static members of the `Clipboard` API, accessible through `fin.Clipboard`.
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(clipboard, "__esModule", { value: true });
+clipboard.Clipboard = void 0;
+const base_1$c = base;
+/**
+ * The Clipboard API allows reading and writing to the clipboard in multiple formats.
+ *
+ */
+class Clipboard extends base_1$c.Base {
+    /**
+     * Writes data into the clipboard as plain text
+     * @param writeObj The object for writing data into the clipboard
+     *
+     * @example
+     * ```js
+     * fin.Clipboard.writeText({
+     *     data: 'hello, world'
+     * }).then(() => console.log('Text On clipboard')).catch(err => console.log(err));
+     * ```
+     */
+    async writeText(writeObj) {
+        await this.wire.sendAction('clipboard-write-text', writeObj);
+    }
+    /**
+     * Read the content of the clipboard as plain text
+     * @param type Clipboard Type defaults to 'clipboard', use 'selection' for linux
+     *
+     * @example
+     * ```js
+     * fin.Clipboard.readText().then(text => console.log(text)).catch(err => console.log(err));
+     * ```
+     */
+    async readText(type) {
+        // NOTE: When we start supporting linux, we could detect the OS and choose 'selection' automatically for the user
+        const { payload } = await this.wire.sendAction('clipboard-read-text', { type });
+        return payload.data;
+    }
+    /**
+     * Writes data into the clipboard as an Image
+     * @param writeRequest The object to write an image to the clipboard
+     *
+     * @example
+     * ```js
+     * fin.Clipboard.writeImage({
+     *   // raw base64 string, or dataURL of either data:image/png or data:image/jpeg type
+     *   image: '...'
+     * }).then(() => console.log('Image written to clipboard')).catch(err => console.log(err));
+     * ```
+     */
+    async writeImage(writeRequest) {
+        await this.wire.sendAction('clipboard-write-image', writeRequest);
+    }
+    /**
+     * Read the content of the clipboard as a base64 string or a dataURL based on the input parameter 'format', defaults to 'dataURL'
+     * @param readRequest Clipboard Read Image request with formatting options
+     *
+     * @example
+     * ```js
+     * // see TS type: OpenFin.ImageFormatOptions
+     *
+     * const pngOrDataURLOrBmpOptions = {
+     *     format: 'png', // can be: 'png' | 'dataURL' | 'bmp'
+     * };
+     *
+     * const jpgOptions = {
+     *     format: 'jpg',
+     *     quality: 80 // optional, if omitted defaults to 100
+     * };
+     *
+     * fin.Clipboard.readImage(pngOrDataURLOrBmpOptions)
+     *     .then(image => console.log('Image read from clipboard as PNG, DataURL or BMP', image))
+     *     .catch(err => console.log(err));
+     *
+     * fin.Clipboard.readImage(jpgOptions)
+     *     .then(image => console.log('Image read from clipboard as JPG', image))
+     *     .catch(err => console.log(err));
+     *
+     * // defaults to {format: 'dataURL'}
+     * fin.Clipboard.readImage()
+     *     .then(image => console.log('Image read from clipboard as DataURL', image))
+     *     .catch(err => console.log(err));
+     *
+     * ```
+     */
+    async readImage(readRequest = { format: 'dataURL' }) {
+        const { payload } = await this.wire.sendAction('clipboard-read-image', readRequest);
+        return payload.data;
+    }
+    /**
+     * Writes data into the clipboard as Html
+     * @param writeObj The object for writing data into the clipboard
+     *
+     * @example
+     * ```js
+     * fin.Clipboard.writeHtml({
+     *         data: '
Hello, World!
'
+     * }).then(() => console.log('HTML On clipboard')).catch(err => console.log(err));
+     * ```
+     */
+    async writeHtml(writeObj) {
+        await this.wire.sendAction('clipboard-write-html', writeObj);
+    }
+    /**
+     * Read the content of the clipboard as Html
+     * @param type Clipboard Type defaults to 'clipboard', use 'selection' for linux
+     *
+     * @example
+     * ```js
+     * fin.Clipboard.readHtml().then(html => console.log(html)).catch(err => console.log(err));
+     * ```
+     */
+    async readHtml(type) {
+        const { payload } = await this.wire.sendAction('clipboard-read-html', { type });
+        return payload.data;
+    }
+    /**
+     * Writes data into the clipboard as Rtf
+     * @param writeObj The object for writing data into the clipboard
+     *
+     * @example
+     * ```js
+     * fin.Clipboard.writeRtf({
+     *         data: 'some text goes here'
+     * }).then(() => console.log('RTF On clipboard')).catch(err => console.log(err));
+     * ```
+     */
+    async writeRtf(writeObj) {
+        await this.wire.sendAction('clipboard-write-rtf', writeObj);
+    }
+    /**
+     * Read the content of the clipboard as Rtf
+     * @param type Clipboard Type defaults to 'clipboard', use 'selection' for linux
+     *
+     * @example
+     *
+     * ```js
+     * const writeObj = {
+     *     data: 'some text goes here'
+     * };
+     * async function readRtf() {
+     *     await fin.Clipboard.writeRtf(writeObj);
+     *     return await fin.Clipboard.readRtf();
+     * }
+     * readRtf().then(rtf => console.log(rtf)).catch(err => console.log(err));
+     * ```
+     */
+    async readRtf(type) {
+        const { payload } = await this.wire.sendAction('clipboard-read-rtf', { type });
+        return payload.data;
+    }
+    /**
+     * Writes data into the clipboard
+     * @param writeObj The object for writing data into the clipboard
+     *
+     * @example
+     * ```js
+     * fin.Clipboard.write({
+     *   data: {
+     *     text: 'a',
+     *     html: 'b',
+     *     rtf: 'c',
+     *     // Can be either a base64 string, or a DataURL string. If using DataURL, the
+     *     // supported formats are `data:image/png[;base64],` and `data:image/jpeg[;base64],`.
+     *     // Using other image/ DataURLs will throw an Error.
+     *     image: '...'
+     *   }
+     * }).then(() => console.log('write data into clipboard')).catch(err => console.log(err));
+     * ```
+     */
+    async write(writeObj) {
+        await this.wire.sendAction('clipboard-write', writeObj);
+    }
+    /**
+     * Reads available formats for the clipboard type
+     * @param type Clipboard Type defaults to 'clipboard', use 'selection' for linux
+     *
+     * @example
+     * ```js
+     * fin.Clipboard.getAvailableFormats().then(formats => console.log(formats)).catch(err => console.log(err));
+     * ```
+     */
+    async getAvailableFormats(type) {
+        const { payload } = await this.wire.sendAction('clipboard-read-formats', { type });
+        return payload.data;
+    }
+}
+clipboard.Clipboard = Clipboard;
+
+var externalApplication = {};
+
+var Factory$5 = {};
+
+var Instance$4 = {};
+
+Object.defineProperty(Instance$4, "__esModule", { value: true });
+Instance$4.ExternalApplication = void 0;
+/* eslint-disable import/prefer-default-export */
+const base_1$b = base;
+/**
+ * An ExternalApplication object representing native language adapter connections to the runtime. Allows
+ * the developer to listen to {@link OpenFin.ExternalApplicationEvents external application events}.
+ * Discovery of connections is provided by {@link System.System.getAllExternalApplications getAllExternalApplications}.
+ *
+ * Processes that can be wrapped as `ExternalApplication`s include the following:
+ * - Processes which have connected to an OpenFin runtime via an adapter
+ * - Processes started via `System.launchExternalApplication`
+ * - Processes monitored via `System.monitorExternalProcess`
+ */
+class ExternalApplication extends base_1$b.EmitterBase {
+    /**
+     * @internal
+     */
+    constructor(wire, identity) {
+        super(wire, 'external-application', identity.uuid);
+        this.identity = identity;
+    }
+    /**
+     * Retrieves information about the external application.
+     *
+     * @example
+     * ```js
+     * async function getInfo() {
+     *     const extApp = await fin.ExternalApplication.wrap('javaApp-uuid');
+     *     return await extApp.getInfo();
+     * }
+     * getInfo().then(info => console.log(info)).catch(err => console.log(err));
+     * ```
+     */
+    getInfo() {
+        return this.wire.sendAction('get-external-application-info', this.identity).then(({ payload }) => payload.data);
+    }
+}
+Instance$4.ExternalApplication = ExternalApplication;
+
+Object.defineProperty(Factory$5, "__esModule", { value: true });
+Factory$5.ExternalApplicationModule = void 0;
+const base_1$a = base;
+const Instance_1$4 = Instance$4;
+/**
+ * Static namespace for OpenFin API methods that interact with the {@link ExternalApplication} class, available under `fin.ExternalApplication`.
+ */
+class ExternalApplicationModule extends base_1$a.Base {
+    /**
+     * Asynchronously returns an External Application object that represents an external application.
+     * 
It is possible to wrap a process that does not yet exist, (for example, to listen for startup-related events)
+     * provided its uuid is already known.
+     * @param uuid The UUID of the external application to be wrapped
+     *
+     * @example
+     * ```js
+     * fin.ExternalApplication.wrap('javaApp-uuid');
+     * .then(extApp => console.log('wrapped external application'))
+     * .catch(err => console.log(err));
+     * ```
+     */
+    wrap(uuid) {
+        this.wire.sendAction('external-application-wrap').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        return Promise.resolve(new Instance_1$4.ExternalApplication(this.wire, { uuid }));
+    }
+    /**
+     * Synchronously returns an External Application object that represents an external application.
+     * 
It is possible to wrap a process that does not yet exist, (for example, to listen for startup-related events)
+     * provided its uuid is already known.
+     * @param uuid The UUID of the external application to be wrapped
+     *
+     * @example
+     * ```js
+     * const extApp = fin.ExternalApplication.wrapSync('javaApp-uuid');
+     * const info = await extApp.getInfo();
+     * console.log(info);
+     * ```
+     */
+    wrapSync(uuid) {
+        this.wire.sendAction('external-application-wrap-sync').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        return new Instance_1$4.ExternalApplication(this.wire, { uuid });
+    }
+}
+Factory$5.ExternalApplicationModule = ExternalApplicationModule;
+
+(function (exports) {
+	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    var desc = Object.getOwnPropertyDescriptor(m, k);
+	    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+	      desc = { enumerable: true, get: function() { return m[k]; } };
+	    }
+	    Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    o[k2] = m[k];
+	}));
+	var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	/**
+	 * Entry points for the OpenFin `ExternalApplication` API (`fin.ExternalApplication`).
+	 *
+	 * * {@link ExternalApplicationModule} contains static members of the `ExternalApplication` type, accessible through `fin.ExternalApplication`.
+	 * * {@link ExternalApplication} describes an instance of an OpenFin ExternalApplication, e.g. as returned by `fin.ExternalApplication.getCurrent`.
+	 *
+	 * These are separate code entities, and are documented separately.  In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/32.114.76.10/index.html),
+	 * both of these were documented on the same page.
+	 *
+	 * @packageDocumentation
+	 */
+	__exportStar(Factory$5, exports);
+	__exportStar(Instance$4, exports); 
+} (externalApplication));
+
+var frame = {};
+
+var Factory$4 = {};
+
+var Instance$3 = {};
+
+Object.defineProperty(Instance$3, "__esModule", { value: true });
+Instance$3._Frame = void 0;
+/* eslint-disable import/prefer-default-export */
+const base_1$9 = base;
+/**
+ * An iframe represents an embedded HTML page within a parent HTML page. Because this embedded page
+ * has its own DOM and global JS context (which may or may not be linked to that of the parent depending
+ * on if it is considered out of the root domain or not), it represents a unique endpoint as an OpenFin
+ * connection. Iframes may be generated dynamically, or be present on initial page load and each non-CORS
+ * iframe has the OpenFin API injected by default. It is possible to opt into cross-origin iframes having
+ * the API by setting api.iframe.crossOriginInjection to true in a window's options. To block all iframes
+ * from getting the API injected you can set api.frame.sameOriginInjection
+ * to false ({@link OpenFin.WindowCreationOptions see Window Options}).
+ *
+ * To be able to directly address this context for eventing and messaging purposes, it needs a
+ * unique uuid name pairing. For OpenFin applications and windows this is provided via a configuration
+ * object in the form of a manifest URL or options object, but there is no configuration object for iframes.
+ * Just as a call to window.open outside of our Window API returns a new window with a random GUID assigned
+ * for the name, each iframe that has the API injected will be assigned a GUID as its name, the UUID will be
+ * the same as the parent window's.
+ *
+ * The fin.Frame namespace represents a way to interact with `iframes` and facilitates the discovery of current context
+ * (iframe or main window) as well as the ability to listen for {@link OpenFin.FrameEvents frame-specific events}.
+ */
+class _Frame extends base_1$9.EmitterBase {
+    /**
+     * @internal
+     */
+    constructor(wire, identity) {
+        super(wire, 'frame', identity.uuid, identity.name);
+        this.identity = identity;
+    }
+    /**
+     * Returns a frame info object for the represented frame.
+     *
+     * @example
+     * ```js
+     * async function getInfo() {
+     *     const frm = await fin.Frame.getCurrent();
+     *     return await frm.getInfo();
+     * }
+     * getInfo().then(info => console.log(info)).catch(err => console.log(err));
+     * ```
+     */
+    getInfo() {
+        return this.wire.sendAction('get-frame-info', this.identity).then(({ payload }) => payload.data);
+    }
+    /**
+     * Returns a frame info object representing the window that the referenced iframe is
+     * currently embedded in.
+     *
+     * @remarks If the frame is embedded in a view, this will return an invalid stub with empty fields.
+     *
+     * @example
+     * ```js
+     * async function getParentWindow() {
+     *     const frm = await fin.Frame.getCurrent();
+     *     return await frm.getParentWindow();
+     * }
+     * getParentWindow().then(winInfo => console.log(winInfo)).catch(err => console.log(err));
+     * ```
+     */
+    getParentWindow() {
+        return this.wire.sendAction('get-parent-window', this.identity).then(({ payload }) => payload.data);
+    }
+}
+Instance$3._Frame = _Frame;
+
+Object.defineProperty(Factory$4, "__esModule", { value: true });
+Factory$4._FrameModule = void 0;
+const base_1$8 = base;
+const validate_1$2 = validate;
+const Instance_1$3 = Instance$3;
+/**
+ * Static namespace for OpenFin API methods that interact with the {@link _Frame} class, available under `fin.Frame`.
+ */
+class _FrameModule extends base_1$8.Base {
+    /**
+     * Asynchronously returns an API handle for the given Frame identity.
+     *
+     * @remarks Wrapping a Frame identity that does not yet exist will *not* throw an error, and instead
+     * returns a stub object that cannot yet perform rendering tasks. This can be useful for plumbing eventing
+     * for a Frame throughout its entire lifecycle.
+     *
+     * @example
+     * ```js
+     * fin.Frame.wrap({ uuid: 'testFrame', name: 'testFrame' })
+     * .then(frm => console.log('wrapped frame'))
+     * .catch(err => console.log(err));
+     * ```
+     */
+    async wrap(identity) {
+        this.wire.sendAction('frame-wrap').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        const errorMsg = (0, validate_1$2.validateIdentity)(identity);
+        if (errorMsg) {
+            throw new Error(errorMsg);
+        }
+        return new Instance_1$3._Frame(this.wire, identity);
+    }
+    /**
+     * Synchronously returns an API handle for the given Frame identity.
+     *
+     * @remarks Wrapping a Frame identity that does not yet exist will *not* throw an error, and instead
+     * returns a stub object that cannot yet perform rendering tasks. This can be useful for plumbing eventing
+     * for a Frame throughout its entire lifecycle.
+     *
+     * @example
+     * ```js
+     * const frm = fin.Frame.wrapSync({ uuid: 'testFrame', name: 'testFrame' });
+     * const info = await frm.getInfo();
+     * console.log(info);
+     * ```
+     */
+    wrapSync(identity) {
+        this.wire.sendAction('frame-wrap-sync').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        const errorMsg = (0, validate_1$2.validateIdentity)(identity);
+        if (errorMsg) {
+            throw new Error(errorMsg);
+        }
+        return new Instance_1$3._Frame(this.wire, identity);
+    }
+    /**
+     * Asynchronously returns a reference to the current frame
+     *
+     * @example
+     * ```js
+     * fin.Frame.getCurrent()
+     * .then(frm => console.log('current frame'))
+     * .catch(err => console.log(err));
+     * ```
+     */
+    getCurrent() {
+        this.wire.sendAction('frame-get-current').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        return Promise.resolve(new Instance_1$3._Frame(this.wire, this.wire.environment.getCurrentEntityIdentity()));
+    }
+    /**
+     * Synchronously returns a reference to the current frame
+     *
+     * @example
+     * ```js
+     * const frm = fin.Frame.getCurrentSync();
+     * const info = await frm.getInfo();
+     * console.log(info);
+     * ```
+     */
+    getCurrentSync() {
+        this.wire.sendAction('frame-get-current-sync').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        return new Instance_1$3._Frame(this.wire, this.wire.environment.getCurrentEntityIdentity());
+    }
+}
+Factory$4._FrameModule = _FrameModule;
+
+(function (exports) {
+	/**
+	 * Entry points for the OpenFin `Frame` API (`fin.Frame`).
+	 *
+	 * * {@link _FrameModule} contains static members of the `Frame` API, accessible through `fin.Frame`.
+	 * * {@link _Frame} describes an instance of an OpenFin Frame, e.g. as returned by `fin.Frame.getCurrent`.
+	 *
+	 * These are separate code entities, and are documented separately. In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/32.114.76.10/index.html),
+	 * both of these were documented on the same page.
+	 *
+	 * Underscore prefixing of OpenFin types that alias DOM entities will be fixed in a future version.
+	 *
+	 * @packageDocumentation
+	 */
+	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    var desc = Object.getOwnPropertyDescriptor(m, k);
+	    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+	      desc = { enumerable: true, get: function() { return m[k]; } };
+	    }
+	    Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    o[k2] = m[k];
+	}));
+	var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	__exportStar(Factory$4, exports);
+	__exportStar(Instance$3, exports); 
+} (frame));
+
+var globalHotkey = {};
+
+Object.defineProperty(globalHotkey, "__esModule", { value: true });
+globalHotkey.GlobalHotkey = void 0;
+const base_1$7 = base;
+/**
+ * The GlobalHotkey module can register/unregister a global hotkeys.
+ *
+ */
+class GlobalHotkey extends base_1$7.EmitterBase {
+    /**
+     * @internal
+     */
+    constructor(wire) {
+        super(wire, 'global-hotkey');
+    }
+    /**
+     * Registers a global hotkey with the operating system.
+     * @param hotkey a hotkey string
+     * @param listener called when the registered hotkey is pressed by the user.
+     * @throws If the `hotkey` is reserved, see list below.
+     * @throws if the `hotkey` is already registered by another application.
+     *
+     * @remarks The `hotkey` parameter expects an electron compatible [accelerator](https://github.com/electron/electron/blob/master/docs/api/accelerator.md) and the `listener` will be called if the `hotkey` is pressed by the user.
+     * If successfull, the hotkey will be 'claimed' by the application, meaning that this register call can be called multiple times from within the same application but will fail if another application has registered the hotkey.
+     * 
The register call will fail if given any of these reserved Hotkeys:
+     * * `CommandOrControl+0`
+     * * `CommandOrControl+=`
+     * * `CommandOrControl+Plus`
+     * * `CommandOrControl+-`
+     * * `CommandOrControl+_`
+     * * `CommandOrControl+Shift+I`
+     * * `F5`
+     * * `CommandOrControl+R`
+     * * `Shift+F5`
+     * * `CommandOrControl+Shift+R`
+     *
+     * Raises the `registered` event.
+     *
+     * @example
+     * ```js
+     * const hotkey = 'CommandOrControl+X';
+     *
+     * fin.GlobalHotkey.register(hotkey, () => {
+     * console.log(`${hotkey} pressed`);
+     * })
+     * .then(() => {
+     *     console.log('Success');
+     * })
+     * .catch(err => {
+     *     console.log('Error registering the hotkey', err);
+     * });
+     * ```
+     */
+    async register(hotkey, listener) {
+        // TODO: fix typing (hotkey events are not typed)
+        // @ts-expect-error
+        await this.on(hotkey, listener);
+        await this.wire.sendAction('global-hotkey-register', { hotkey });
+        return undefined;
+    }
+    /**
+     * Unregisters a global hotkey with the operating system.
+     * @param hotkey a hotkey string
+     *
+     * @remarks This method will unregister all existing registrations of the hotkey within the application.
+     * Raises the `unregistered` event.
+     *
+     * @example
+     * ```js
+     * const hotkey = 'CommandOrControl+X';
+     *
+     * fin.GlobalHotkey.unregister(hotkey)
+     * .then(() => {
+     *     console.log('Success');
+     * })
+     * .catch(err => {
+     *     console.log('Error unregistering the hotkey', err);
+     * });
+     * ```
+     */
+    async unregister(hotkey) {
+        // TODO: fix typing (hotkey events are not typed)
+        // @ts-expect-error
+        await this.removeAllListeners(hotkey);
+        await this.wire.sendAction('global-hotkey-unregister', { hotkey });
+        return undefined;
+    }
+    /**
+     * Unregisters all global hotkeys for the current application.
+     *
+     * @remarks Raises the `unregistered` event for each hotkey unregistered.
+     *
+     * @example
+     * ```js
+     * fin.GlobalHotkey.unregisterAll()
+     * .then(() => {
+     *     console.log('Success');
+     * })
+     * .catch(err => {
+     *     console.log('Error unregistering all hotkeys for this application', err);
+     * });
+     * ```
+     */
+    async unregisterAll() {
+        await Promise.all(this.eventNames()
+            .filter((name) => !(name === 'registered' || name === 'unregistered'))
+            // TODO: fix typing (hotkey events are not typed)
+            // @ts-expect-error
+            .map((name) => this.removeAllListeners(name)));
+        await this.wire.sendAction('global-hotkey-unregister-all', {});
+        return undefined;
+    }
+    /**
+     * Checks if a given hotkey has been registered by an application within the current runtime.
+     * @param hotkey a hotkey string
+     *
+     * @example
+     * ```js
+     * const hotkey = 'CommandOrControl+X';
+     *
+     * fin.GlobalHotkey.isRegistered(hotkey)
+     * .then((registered) => {
+     *     console.log(`hotkey ${hotkey} is registered ? ${registered}`);
+     * })
+     * .catch(err => {
+     *     console.log('Error unregistering the hotkey', err);
+     * });
+     * ```
+     */
+    async isRegistered(hotkey) {
+        const { payload: { data } } = await this.wire.sendAction('global-hotkey-is-registered', { hotkey });
+        return data;
+    }
+}
+globalHotkey.GlobalHotkey = GlobalHotkey;
+
+var platform = {};
+
+var Factory$3 = {};
+
+var Instance$2 = {};
+
+var __classPrivateFieldGet$5 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Platform_connectToProvider;
+Object.defineProperty(Instance$2, "__esModule", { value: true });
+Instance$2.Platform = void 0;
+/* eslint-disable import/prefer-default-export, no-undef */
+const base_1$6 = base;
+const validate_1$1 = validate;
+// Reuse clients to avoid overwriting already-registered client in provider
+const clientMap = new Map();
+/** Manages the life cycle of windows and views in the application.
+ *
+ * Enables taking snapshots of itself and applying them to restore a previous configuration
+ * as well as listen to {@link OpenFin.PlatformEvents platform events}.
+ */
+class Platform extends base_1$6.EmitterBase {
+    /**
+     * @internal
+     */
+    // eslint-disable-next-line no-shadow
+    constructor(identity, channel) {
+        // we piggyback off of application event emitter because from the core's perspective platform is just an app.
+        super(channel.wire, 'application', identity.uuid);
+        this.getClient = (identity) => {
+            this.wire.sendAction('platform-get-client', this.identity).catch((e) => {
+                // don't expose
+            });
+            const target = identity || this.identity;
+            const { uuid } = target;
+            if (!clientMap.has(uuid)) {
+                const clientPromise = __classPrivateFieldGet$5(this, _Platform_connectToProvider, "f").call(this, uuid);
+                clientMap.set(uuid, clientPromise);
+            }
+            // we set it above
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            return clientMap.get(uuid);
+        };
+        _Platform_connectToProvider.set(this, async (uuid) => {
+            try {
+                const channelName = `custom-frame-${uuid}`;
+                const client = await this._channel.connect(channelName, { wait: false });
+                client.onDisconnection(() => {
+                    clientMap.delete(uuid);
+                });
+                return client;
+            }
+            catch (e) {
+                clientMap.delete(uuid);
+                throw new Error('The targeted Platform is not currently running. Listen for application-started event for the given Uuid.');
+            }
+        });
+        /**
+         * @deprecated (renamed)
+         * @ignore
+         */
+        this.launchLegacyManifest = this.launchContentManifest;
+        const errorMsg = (0, validate_1$1.validateIdentity)(identity);
+        if (errorMsg) {
+            throw new Error(errorMsg);
+        }
+        this._channel = channel;
+        this.identity = { uuid: identity.uuid };
+        this.Layout = this.fin.Platform.Layout;
+        this.Application = this.fin.Application.wrapSync(this.identity);
+    }
+    /**
+     * Creates a new view and attaches it to a specified target window.
+     * @param viewOptions View creation options
+     * @param target The window to which the new view is to be attached. If no target, create a view in a new window.
+     * @param targetView If provided, the new view will be added to the same tabstrip as targetView.
+     *
+     * @remarks If the view already exists, will reparent the view to the new target. You do not need to set a name for a View.
+     * Views that are not passed a name get a randomly generated one.
+     *
+     * @example
+     * ```js
+     * let windowIdentity;
+     * if (fin.me.isWindow) {
+     *     windowIdentity = fin.me.identity;
+     * } else if (fin.me.isView) {
+     *     windowIdentity = (await fin.me.getCurrentWindow()).identity;
+     * } else {
+     *     throw new Error('Not running in a platform View or Window');
+     * }
+     *
+     * const platform = fin.Platform.getCurrentSync();
+     *
+     * platform.createView({
+     *     name: 'test_view',
+     *     url: 'https://developers.openfin.co/docs/platform-api'
+     * }, windowIdentity).then(console.log);
+     * ```
+     *
+     * Reparenting a view:
+     * ```js
+     * let windowIdentity;
+     * if (fin.me.isWindow) {
+     *     windowIdentity = fin.me.identity;
+     * } else if (fin.me.isView) {
+     *     windowIdentity = (await fin.me.getCurrentWindow()).identity;
+     * } else {
+     *     throw new Error('Not running in a platform View or Window');
+     * }
+     *
+     * let platform = fin.Platform.getCurrentSync();
+     * let viewOptions = {
+     *     name: 'example_view',
+     *     url: 'https://example.com'
+     * };
+     * // a new view will now show in the current window
+     * await platform.createView(viewOptions, windowIdentity);
+     *
+     * const view = fin.View.wrapSync({ uuid: windowIdentity.uuid, name: 'yahoo_view' });
+     * // reparent `example_view` when a view in the new window is shown
+     * view.on('shown', async () => {
+     *     let viewIdentity = { uuid: windowIdentity.uuid, name: 'example_view'};
+     *     let target = {uuid: windowIdentity.uuid, name: 'test_win'};
+     *     platform.createView(viewOptions, target);
+     * });
+     *
+     * // create a new window
+     * await platform.createWindow({
+     *     name: "test_win",
+     *     layout: {
+     *         content: [
+     *             {
+     *                 type: 'stack',
+     *                 content: [
+     *                     {
+     *                         type: 'component',
+     *                         componentName: 'view',
+     *                         componentState: {
+     *                             name: 'yahoo_view',
+     *                             url: 'https://yahoo.com'
+     *                         }
+     *                     }
+     *                 ]
+     *             }
+     *         ]
+     *     }
+     * }).then(console.log);
+     * ```
+     */
+    async createView(viewOptions, target, targetView) {
+        this.wire.sendAction('platform-create-view', this.identity).catch((e) => {
+            // don't expose
+        });
+        const client = await this.getClient();
+        const response = await client.dispatch('create-view', {
+            target,
+            opts: viewOptions,
+            targetView
+        });
+        if (!response || (0, validate_1$1.validateIdentity)(response.identity)) {
+            throw new Error(`When overwriting the createView call, please return an object that has a valid 'identity' property: ${JSON.stringify(response)}`);
+        }
+        return this.fin.View.wrapSync(response.identity);
+    }
+    /**
+     * Creates a new Window.
+     * @param options Window creation options
+     *
+     * @remarks There are two Window types at your disposal while using OpenFin Platforms - Default Window and Custom Window.
+     *
+     * The Default Window uses the standard OpenFin Window UI. It contains the standard close, maximize and minimize buttons,
+     * and will automatically render the Window's layout if one is specified.
+     *
+     * For deeper customization, you can bring your own Window code into a Platform. This is called a Custom Window.
+     *
+     * @example
+     *
+     *
+     * The example below will create a Default Window which uses OpenFin default Window UI.

+     * The Window contains two Views in a stack Layout:
+     *
+     * ```js
+     * const platform = fin.Platform.getCurrentSync();
+     * platform.createWindow({
+     *     layout: {
+     *         content: [
+     *             {
+     *                 type: 'stack',
+     *                 content: [
+     *                     {
+     *                         type: 'component',
+     *                         componentName: 'view',
+     *                         componentState: {
+     *                             name: 'test_view_1',
+     *                             url: 'https://cdn.openfin.co/docs/javascript/canary/Platform.html'
+     *                         }
+     *                     },
+     *                     {
+     *                         type: 'component',
+     *                         componentName: 'view',
+     *                         componentState: {
+     *                             name: 'test_view_2',
+     *                             url: 'https://cdn.openfin.co/docs/javascript/canary/Platform.html'
+     *                         }
+     *                     }
+     *                 ]
+     *             }
+     *         ]
+     *     }
+     * }).then(console.log);
+     * ```
+     * The Default Window's design can be customized by specifying the `stylesheetUrl` property in the manifest:
+     *
+     * ```json
+     * {
+     *     platform: {
+     *         defaultWindowOptions: {
+     *             stylesheetUrl: 'some-url.css',
+     *             ...
+     *         }
+     *     }
+     * }
+     * ```
+     * For a list of common Layout CSS classes you can override in your custom stylesheet, see Useful Layout CSS Classes
+     **
+     * To specify a Platform Custom Window, provide a `url` property when creating a Window.
+     * If you intend to render a Layout in your Custom Window, you must also specify an `HTMLElement` that the Layout will inject into and set its `id` property to `"layout-container"`.
+     *
+     * The example below will create a Platform Custom Window:
+     *
+     * ```js
+     *     // in an OpenFin app:
+     *     const platform = fin.Platform.getCurrentSync();
+     *     const windowConfig =
+     *         {
+     *             url: "https://www.my-domain.com/my-custom-window.html", // here we point to where the Custom Frame is hosted.
+     *             layout: {
+     *                 content: [
+     *                     {
+     *                         type: "stack",
+     *                         content: [
+     *                             {
+     *                                 type: "component",
+     *                                 componentName: "view",
+     *                                 componentState: {
+     *                                     name: "app #1",
+     *                                     url: "https://cdn.openfin.co/docs/javascript/canary/Platform.html"
+     *                                 }
+     *                             },
+     *                             {
+     *                                 type: "component",
+     *                                 componentName: "view",
+     *                                 componentState: {
+     *                                     name: "app #2",
+     *                                     url: "https://cdn.openfin.co/docs/javascript/canary/Platform.html"
+     *                                 }
+     *                             }
+     *                         ]
+     *                     }
+     *                 ]
+     *             }
+     *         };
+     *     platform.createWindow(windowConfig);
+     * ```
+     *
+     * Here's an example of a minimalist Custom Platform Window implementation:
+     * ```html
+     * 
+     *     
+     *         
+     *         
+     *         
+     *     
+     *     
+     *         

+     *             

+     *                 

+     *                     
 This is a custom frame! 

+     *                 

+     *                 

+     *                     

+     *                     

+     *                     

+     *                 

+     *             

+     *             
 
+     *             
+     *         

+     *     
+     * 
+     * ```
+     * Your Custom Window can use in-domain resources for further customization (such as CSS, scripts, etc.).

+     * For a list of common Layout CSS classes you can override in your stylesheet, see Useful Layout CSS Classes
+     *
+     * The example above will require the `body` element to have `height: 100%;` set in order to render the layout correctly.
+     */
+    async createWindow(options) {
+        this.wire.sendAction('platform-create-window', this.identity).catch((e) => {
+            // don't expose
+        });
+        const client = await this.getClient();
+        if (!options.reason) {
+            options.reason = 'api-call';
+        }
+        const response = await client.dispatch('create-view-container', options);
+        if (!response || (0, validate_1$1.validateIdentity)(response.identity)) {
+            throw new Error(`When overwriting the createWindow call, please return an object that has a valid 'identity' property: ${JSON.stringify(response)}`);
+        }
+        const { identity } = response;
+        const res = this.fin.Window.wrapSync(identity);
+        // we add the identity at the top level for backwards compatibility.
+        res.name = identity.name;
+        res.uuid = identity.uuid;
+        return res;
+    }
+    /**
+     * Closes current platform, all its windows, and their views.
+     *
+     * @example
+     * ```js
+     * const platform = await fin.Platform.getCurrent();
+     * platform.quit();
+     * // All windows/views in current layout platform will close and platform will shut down
+     * ```
+     */
+    async quit() {
+        this.wire.sendAction('platform-quit', this.identity).catch((e) => {
+            // don't expose
+        });
+        const client = await this.getClient();
+        return client.dispatch('quit');
+    }
+    /**
+     * Closes a specified view in a target window.
+     * @param viewIdentity View identity
+     *
+     * @example
+     * ```js
+     * let windowIdentity;
+     * if (fin.me.isWindow) {
+     *     windowIdentity = fin.me.identity;
+     * } else if (fin.me.isView) {
+     *     windowIdentity = (await fin.me.getCurrentWindow()).identity;
+     * } else {
+     *     throw new Error('Not running in a platform View or Window');
+     * }
+     *
+     * const viewOptions = {
+     *     name: 'test_view',
+     *     url: 'https://example.com'
+     * };
+     *
+     * function sleep(ms) {
+     *     return new Promise(resolve => setTimeout(resolve, ms));
+     * }
+     *
+     * const platform = await fin.Platform.getCurrent();
+     *
+     * await platform.createView(viewOptions, windowIdentity);
+     * // a new view will now show in the current window
+     *
+     * await sleep(5000);
+     *
+     * const viewIdentity = { uuid: windowIdentity.uuid, name: 'test_view'};
+     * platform.closeView(viewIdentity);
+     * // the view will now close
+     * ```
+     */
+    async closeView(viewIdentity) {
+        this.wire.sendAction('platform-close-view', this.identity).catch((e) => {
+            // don't expose
+        });
+        const client = await this.getClient();
+        await client.dispatch('close-view', {
+            view: viewIdentity
+        });
+    }
+    /**
+     * ***DEPRECATED - please use {@link Platform.createView Platform.createView}.***
+     * Reparents a specified view in a new target window.
+     * @param viewIdentity View identity
+     * @param target new owner window identity
+     *
+     */
+    async reparentView(viewIdentity, target) {
+        // eslint-disable-next-line no-console
+        console.warn('Platform.reparentView has been deprecated, please use Platform.createView');
+        this.wire.sendAction('platform-reparent-view', this.identity).catch((e) => {
+            // don't expose
+        });
+        const normalizedViewIdentity = {
+            ...viewIdentity,
+            uuid: viewIdentity.uuid ?? this.identity.uuid
+        };
+        const view = await this.fin.View.wrap(normalizedViewIdentity);
+        const viewOptions = await view.getOptions();
+        return this.createView(viewOptions, target);
+    }
+    /**
+     * Returns a snapshot of the platform in its current state. You can pass the returning object to
+     * [Platform.applySnapshot]{@link Platform#applySnapshot} to launch it.
+     *
+     * @remarks The snapshot will include details such as an [ISO format](https://en.wikipedia.org/wiki/ISO_8601)
+     * timestamp of when the snapshot was taken, OpenFin runtime version the platform is running on, monitor information
+     * and the list of currently running windows.
+     *
+     * @example
+     * ```js
+     * const platform = await fin.Platform.getCurrent();
+     * const snapshot = await platform.getSnapshot();
+     * ```
+     */
+    async getSnapshot() {
+        this.wire.sendAction('platform-get-snapshot', this.identity).catch((e) => {
+            // don't expose
+        });
+        const client = await this.getClient();
+        return client.dispatch('get-snapshot');
+    }
+    /**
+     * **NOTE**: Internal use only. It is not recommended to manage the state of individual views.
+     *
+     * Returns a snapshot of a single view's options in its current state.
+     *
+     * Can be used to restore a view to a previous state.
+     *
+     * @param viewIdentity View identity
+     *
+     * @internal
+     * @experimental
+     * @remarks This slice of snapshot state is equivalent to what is stored as `componentState` for views
+     * when capturing platform state using [Platform.getSnapshot]{@link Platform#getSnapshot}.
+     *
+     * @example
+     * ```js
+     * const platform = await fin.Platform.getCurrent();
+     * const url = 'https://google.com';
+     * const view = await fin.View.create({ name: 'my-view', target: fin.me.identity, url });
+     *
+     * await view.navigate(url);
+     *
+     * const viewState = await platform.getViewSnapshot(view.identity);
+     *
+     * console.log(viewState);
+     * ```
+     */
+    async getViewSnapshot(viewIdentity) {
+        const client = await this.getClient();
+        return client.dispatch('get-view-snapshot', { viewIdentity });
+    }
+    /**
+     * Adds a snapshot to a running Platform.
+     * Requested snapshot must be a valid Snapshot object, or a url or filepath to such an object.
+     *
+     * Can optionally close existing windows and overwrite current platform state with that of a snapshot.
+     *
+     * The function accepts either a snapshot taken using {@link Platform#getSnapshot getSnapshot},
+     * or a url or filepath to a snapshot JSON object.
+     * @param requestedSnapshot Snapshot to apply, or a url or filepath.
+     * @param options Optional parameters to specify whether existing windows should be closed.
+     *
+     * @remarks Will create any windows and views that are not running but are passed in the snapshot object. Any View
+     * specified in the snapshot is assigned a randomly generated name to avoid collisions.
+     *
+     * @example
+     * ```js
+     * // Get a wrapped layout platform instance
+     * const platform = await fin.Platform.getCurrent();
+     *
+     * const snapshot = {
+     *     windows: [
+     *         {
+     *             layout: {
+     *                 content: [
+     *                     {
+     *                         type: 'stack',
+     *                         content: [
+     *                             {
+     *                                 type: 'component',
+     *                                 componentName: 'view',
+     *                                 componentState: {
+     *                                     name: 'component_X',
+     *                                     url: 'https://www.openfin.co'
+     *                                 }
+     *                             },
+     *                             {
+     *                                 type: 'component',
+     *                                 componentName: 'view',
+     *                                 componentState: {
+     *                                     name: 'component_Y',
+     *                                     url: 'https://cdn.openfin.co/embed-web/chart.html'
+     *                                 }
+     *                             }
+     *                         ]
+     *                     }
+     *                 ]
+     *             }
+     *         }
+     *     ]
+     * }
+     *
+     * platform.applySnapshot(snapshot);
+     * ```
+     *
+     * In place of a snapshot object, `applySnapshot` can take a url or filepath and to retrieve a JSON snapshot.
+     *
+     * ```js
+     * const platform = await fin.Platform.getCurrent();
+     * platform.applySnapshot('https://api.jsonbin.io/b/5e6f903ef4331e681fc1231d/1');
+     * ```
+     *
+     * Optionally, `applySnapshot` can close existing windows and restore a Platform to a previously saved state.
+     * This is accomplished by providing `{ closeExistingWindows: true }` as an option.
+     *
+     * ```js
+     * // Get a wrapped layout platform instance
+     * const platform = await fin.Platform.getCurrent();
+     *
+     * async function addViewToWindow(winId) {
+     *     return await platform.createView({
+     *         name: 'test_view_3',
+     *         url: 'https://openfin.co'
+     *     }, winId);
+     * }
+     *
+     * async function createWindowWithTwoViews() {
+     *     const platform = await fin.Platform.getCurrent();
+     *
+     *     return platform.createWindow({
+     *         layout: {
+     *             content: [
+     *                 {
+     *                     type: 'stack',
+     *                     content: [
+     *                         {
+     *                             type: 'component',
+     *                             componentName: 'view',
+     *                             componentState: {
+     *                                 name: 'test_view_1',
+     *                                 url: 'https://example.com'
+     *                             }
+     *                         },
+     *                         {
+     *                             type: 'component',
+     *                             componentName: 'view',
+     *                             componentState: {
+     *                                 name: 'test_view_2',
+     *                                 url: 'https://yahoo.com'
+     *                             }
+     *                         }
+     *                     ]
+     *                 }
+     *             ]
+     *         }
+     *     });
+     * }
+     *
+     * const win = await createWindowWithTwoViews();
+     * // ... you will now see a new window with two views in it
+     *
+     * // we take a snapshot of the current state of the app, before changing it
+     * const snapshotOfInitialAppState = await platform.getSnapshot();
+     *
+     * // now let's change the state of the app:
+     * await addViewToWindow(win.identity);
+     * // ... the window now has three views in it
+     *
+     * await platform.applySnapshot(snapshotOfInitialAppState, { closeExistingWindows: true });
+     * // ... the window will revert to previous state, with just two views
+     *
+     * ```
+     */
+    async applySnapshot(requestedSnapshot, options) {
+        this.wire.sendAction('platform-apply-snapshot', this.identity).catch((e) => {
+            // don't expose
+        });
+        const errMsg = 'Requested snapshot must be a valid Snapshot object, or a url or filepath to such an object.';
+        let snapshot;
+        if (typeof requestedSnapshot === 'string') {
+            // Fetch and parse snapshot
+            try {
+                const response = await this._channel.wire.sendAction('get-application-manifest', {
+                    manifestUrl: requestedSnapshot
+                });
+                snapshot = response.payload.data;
+            }
+            catch (err) {
+                throw new Error(`${errMsg}: ${err}`);
+            }
+        }
+        else {
+            snapshot = requestedSnapshot;
+        }
+        if (!snapshot.windows) {
+            throw new Error(errMsg);
+        }
+        const client = await this.getClient();
+        await client.dispatch('apply-snapshot', {
+            snapshot,
+            options
+        });
+        return this;
+    }
+    /**
+     * Fetches a JSON manifest using the browser process and returns a Javascript object.
+     * Can be overwritten using {@link Platform.PlatformModule.init Platform.init}.
+     * @param manifestUrl The URL of the manifest to fetch.
+     *
+     * @remarks Can be overwritten using {@link Platform#init Platform.init}.
+     *
+     * @example
+     *
+     * ```js
+     * const platform = fin.Platform.getCurrentSync();
+     * const manifest = await platform.fetchManifest('https://www.path-to-manifest.com/app.json');
+     * console.log(manifest);
+     * ```
+     */
+    async fetchManifest(manifestUrl) {
+        const client = await this.getClient();
+        return client.dispatch('platform-fetch-manifest', { manifestUrl });
+    }
+    /**
+     * Retrieves a manifest by url and launches a legacy application manifest or snapshot into the platform.  Returns a promise that
+     * resolves to the wrapped Platform.
+     * @param manifestUrl - The URL of the manifest that will be launched into the platform.  If this app manifest
+     * contains a snapshot, that will be launched into the platform.  If not, the application described in startup_app options
+     * will be launched into the platform. The applicable startup_app options will become {@link OpenFin.ViewCreationOptions View Options}.
+     *
+     * @remarks If the app manifest contains a snapshot, that will be launched into the platform.  If not, the
+     * application described in startup_app options will be launched into the platform as a window with a single view.
+     * The applicable startup_app options will become View Options.
+     *
+     * @example
+     * ```js
+     * try {
+     *     const platform = fin.Platform.getCurrentSync();
+     *     await platform.launchContentManifest('http://localhost:5555/app.json');
+     *     console.log(`content launched successfully into platform`);
+     * } catch(e) {
+     *     console.error(e);
+     * }
+     * // For a local manifest file:
+     * try {
+     *     const platform = fin.Platform.getCurrentSync();
+     *     platform.launchContentManifest('file:///C:/somefolder/app.json');
+     *     console.log(`content launched successfully into platform`);
+     * } catch(e) {
+     *     console.error(e);
+     * }
+     * ```
+     * @experimental
+     */
+    async launchContentManifest(manifestUrl) {
+        this.wire.sendAction('platform-launch-content-manifest', this.identity).catch(() => {
+            // don't expose
+        });
+        const client = await this.getClient();
+        const manifest = await this.fetchManifest(manifestUrl);
+        client.dispatch('launch-into-platform', { manifest, manifestUrl });
+        return this;
+    }
+    /**
+     * Set the context of a host window. The context will be available to the window itself, and to its child Views. It will be saved in any platform snapshots.
+     * It can be retrieved using {@link Platform#getWindowContext getWindowContext}.
+     * @param context - A field where serializable context data can be stored to be saved in platform snapshots.
+     * @param target - A target window or view may optionally be provided. If no target is provided, the update will be applied
+     * to the current window (if called from a Window) or the current host window (if called from a View).
+     *
+     * @remarks The context data must be serializable.  This can only be called from a window or view that has been launched into a
+     * platform.
+     * This method can be called from the window itself, or from any child view. Context data is shared by all
+     * entities within a window.
+     *
+     * @example
+     * Setting own context:
+     * ```js
+     * const platform = fin.Platform.getCurrentSync();
+     * const contextData = {
+     *     security: 'STOCK',
+     *     currentView: 'detailed'
+     * }
+     *
+     * await platform.setWindowContext(contextData);
+     * // Context of current window is now set to `contextData`
+     * ```
+     *
+     * Setting the context of another window or view:
+     * ```js
+     * const platform = fin.Platform.getCurrentSync();
+     * const contextData = {
+     *     security: 'STOCK',
+     *     currentView: 'detailed'
+     * }
+     *
+     * const windowOrViewIdentity = { uuid: fin.me.uuid, name: 'nameOfWindowOrView' };
+     * await platform.setWindowContext(contextData, windowOrViewIdentity);
+     * // Context of the target window or view is now set to `contextData`
+     * ```
+     *
+     * A view can listen to changes to its host window's context by listening to the `host-context-changed` event.
+     * This event will fire when a host window's context is updated or when the view is reparented to a new window:
+     *
+     * ```js
+     * // From a view
+     * const contextChangeHandler = ({ context }) => {
+     *     console.log('Host window\'s context has changed. New context data:', context);
+     *     // react to new context data here
+     * }
+     * await fin.me.on('host-context-changed', contextChangeHandler);
+     *
+     * const platform = await fin.Platform.getCurrentSync();
+     * const contextData = {
+     *     security: 'STOCK',
+     *     currentView: 'detailed'
+     * }
+     * platform.setWindowContext(contextData) // contextChangeHandler will log the new context
+     * ```
+     *
+     * To listen to a window's context updates, use the `context-changed` event:
+     * ```js
+     * // From a window
+     * const contextChangeHandler = ({ context }) => {
+     *     console.log('This window\'s context has changed. New context data:', context);
+     *     // react to new context data here
+     * }
+     * await fin.me.on('context-changed', contextChangeHandler);
+     *
+     * const platform = await fin.Platform.getCurrentSync();
+     * const contextData = {
+     *     security: 'STOCK',
+     *     currentView: 'detailed'
+     * }
+     * platform.setWindowContext(contextData) // contextChangeHandler will log the new context
+     * ```
+     * @experimental
+     */
+    async setWindowContext(context = {}, target) {
+        this.wire.sendAction('platform-set-window-context', this.identity).catch((e) => {
+            // don't expose
+        });
+        if (!context) {
+            throw new Error('Please provide a serializable object or string to set the context.');
+        }
+        const client = await this.getClient();
+        const { entityType } = target ? await this.fin.System.getEntityInfo(target.uuid, target.name) : this.fin.me;
+        await client.dispatch('set-window-context', {
+            context,
+            entityType,
+            target: target || { uuid: this.fin.me.uuid, name: this.fin.me.name }
+        });
+    }
+    /**
+     * Get the context context of a host window that was previously set using {@link Platform#setWindowContext setWindowContext}.
+     * The context will be saved in any platform snapshots.  Returns a promise that resolves to the context.
+     * @param target - A target window or view may optionally be provided. If no target is provided, target will be
+     * the current window (if called from a Window) or the current host window (if called from a View).
+     *
+     * @remarks This method can be called from the window itself, or from any child view. Context data is shared
+     * by all entities within a window.
+     *
+     * @example
+     *
+     * Retrieving context from current window:
+     * ```js
+     * const platform = fin.Platform.getCurrentSync();
+     * const customContext = { answer: 42 };
+     * await platform.setWindowContext(customContext);
+     *
+     * const myContext = await platform.getWindowContext();
+     * console.log(myContext); // { answer: 42 }
+     * ```
+     *
+     * Retrieving the context of another window or view:
+     * ```js
+     * const platform = fin.Platform.getCurrentSync();
+     *
+     * const windowOrViewIdentity = { uuid: fin.me.uuid, name: 'nameOfWindowOrView' };
+     *
+     * const targetWindowContext = await platform.getWindowContext(windowOrViewIdentity);
+     * console.log(targetWindowContext); // context of target window
+     * ```
+     * @experimental
+     */
+    async getWindowContext(target) {
+        this.wire.sendAction('platform-get-window-context', this.identity).catch((e) => {
+            // don't expose
+        });
+        const client = await this.getClient();
+        const { entityType } = target ? await this.fin.System.getEntityInfo(target.uuid, target.name) : this.fin.me;
+        return client.dispatch('get-window-context', {
+            target: target || { uuid: this.fin.me.uuid, name: this.fin.me.name },
+            entityType
+        });
+    }
+    /**
+     * Closes a window. If enableBeforeUnload is enabled in the Platform options, any beforeunload handler set on Views will fire
+     * This behavior can be disabled by setting skipBeforeUnload to false in the options parameter.
+     * @param winId
+     * @param options
+     *
+     * @remarks This method works by setting a `close-requested` handler on the Platform Window. If you have your own `close-requested` handler set on the Platform Window as well,
+     * it is recommended to move that logic over to the [PlatformProvider.closeWindow]{@link PlatformProvider#closeWindow} override to ensure it runs when the Window closes.
+     *
+     * @example
+     *
+     * ```js
+     * // Close the current Window inside a Window context
+     * const platform = await fin.Platform.getCurrent();
+     * platform.closeWindow(fin.me.identity);
+     *
+     * // Close the Window from inside a View context
+     * const platform = await fin.Platform.getCurrent();
+     * const parentWindow = await fin.me.getCurrentWindow();
+     * platform.closeWindow(parentWindow.identity);
+     *
+     * // Close the Window and do not fire the before unload handler on Views
+     * const platform = await fin.Platform.getCurrent();
+     * platform.closeWindow(fin.me.identity, { skipBeforeUnload: true });
+     * ```
+     * @experimental
+     */
+    async closeWindow(windowId, options = { skipBeforeUnload: false }) {
+        this.wire.sendAction('platform-close-window', this.identity).catch((e) => {
+            // don't expose
+        });
+        const client = await this.getClient();
+        return client.dispatch('close-window', { windowId, options });
+    }
+}
+Instance$2.Platform = Platform;
+_Platform_connectToProvider = new WeakMap();
+
+var layout = {};
+
+var Factory$2 = {};
+
+var Instance$1 = {};
+
+var commonUtils = {};
+
+Object.defineProperty(commonUtils, "__esModule", { value: true });
+commonUtils.overrideFromComposables = commonUtils.isValidPresetType = void 0;
+function isValidPresetType(type) {
+    switch (type) {
+        case 'columns':
+        case 'grid':
+        case 'rows':
+        case 'tabs':
+            return true;
+        default:
+            return false;
+    }
+}
+commonUtils.isValidPresetType = isValidPresetType;
+function overrideFromComposables(...overrides) {
+    return (base) => overrides.reduceRight((p, c) => (b) => c(p(b)), (x) => x)(base);
+}
+commonUtils.overrideFromComposables = overrideFromComposables;
+commonUtils.default = { isValidPresetType };
+
+var __classPrivateFieldGet$4 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Layout_layoutClient;
+Object.defineProperty(Instance$1, "__esModule", { value: true });
+Instance$1.Layout = void 0;
+const lazy_1 = lazy;
+const validate_1 = validate;
+const base_1$5 = base;
+const common_utils_1 = commonUtils;
+const layout_entities_1 = layoutEntities;
+const layout_constants_1$1 = layout_constants;
+/**
+ *
+ * Layouts give app providers the ability to embed multiple views in a single window. The Layout namespace
+ * enables the initialization and manipulation of a window's Layout. A Layout will
+ * emit events locally on the DOM element representing the layout-container.
+ *
+ *
+ * ### Layout.DOMEvents
+ *
+ * When a Layout is created, it emits events onto the DOM element representing the Layout container.
+ * This Layout container is the DOM element referenced by containerId in {@link Layout.LayoutModule#init Layout.init}.
+ * You can use the built-in event emitter to listen to these events using [addEventListener](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener).
+ * The events are emitted synchronously and only in the process where the Layout exists.
+ * Any values returned by the called listeners are ignored and will be discarded.
+ * If the target DOM element is destroyed, any events that have been set up on that element will be destroyed.
+ *
+ * @remarks The built-in event emitter is not an OpenFin event emitter so it doesn't share propagation semantics.
+ *
+ * #### {@link https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener addEventListener(type, listener [, options]);}
+ * Adds a listener to the end of the listeners array for the specified event.
+ * @example
+ * ```js
+ * const myLayoutContainer = document.getElementById('layout-container');
+ *
+ * myLayoutContainer.addEventListener('tab-created', function(event) {
+ *      const { tabSelector } = event.detail;
+ *      const tabElement = document.getElementById(tabSelector);
+ *      const existingColor = tabElement.style.backgroundColor;
+ *      tabElement.style.backgroundColor = "red";
+ *      setTimeout(() => {
+ *          tabElement.style.backgroundColor = existingColor;
+ *      }, 2000);
+ * });
+ * ```
+ *
+ * #### {@link https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/removeEventListener removeEventListener(type, listener [, options]);}
+ * Adds a listener to the end of the listeners array for the specified event.
+ * @example
+ * ```js
+ * const myLayoutContainer = document.getElementById('layout-container');
+ *
+ * const listener = function(event) {
+ *     console.log(event.detail);
+ *     console.log('container-created event fired once, removing listener');
+ *     myLayoutContainer.removeEventListener('container-created', listener);
+ * };
+ *
+ * myLayoutContainer.addEventListener('container-created', listener);
+ * ```
+ *
+ * ### Supported event types are:
+ *
+ * * tab-created
+ * * container-created
+ * * layout-state-changed
+ * * tab-closed
+ * * tab-dropped
+ *
+ * ### Layout DOM Node Events
+ *
+ * #### tab-created
+ * Generated when a tab is created.  As a user drags and drops tabs within window, new tabs are created.  A single view may have multiple tabs created and destroyed during its lifetime attached to a single window.
+ * ```js
+ * // The response has the following shape in event.detail:
+ * {
+ *     containerSelector: "container-component_A",
+ *     name: "component_A",
+ *     tabSelector: "tab-component_A",
+ *     topic: "openfin-DOM-event",
+ *     type: "tab-created",
+ *     uuid: "OpenFin POC"
+ * }
+ * ```
+ *
+ * #### container-created
+ * Generated when a container is created.  A single view will have only one container during its lifetime attached to a single window and the container's lifecycle is tied to the view.  To discover when the container is destroyed, please listen to view-detached event.
+ * ```js
+ * // The response has the following shape in event.detail:
+ * {
+ *     containerSelector: "container-component_A",
+ *     name: "component_A",
+ *     tabSelector: "tab-component_A",
+ *     topic: "openfin-DOM-event",
+ *     type: "container-created",
+ *     uuid: "OpenFin POC"
+ * }
+ * ```
+ *
+ * ### layout-state-changed
+ * Generated when the state of the layout changes in any way, such as a view added/removed/replaced. Note that this event can fire frequently as the underlying layout can change multiple components from all kinds of changes (resizing for example). Given this, it is recommended to debounce this event and then you can use the {@link Layout#getConfig Layout.getConfig} API to retrieve the most up-to-date state.
+ * ```js
+ * // The response has the following shape in event.detail
+ * {
+ *     containerSelector: "container-component_A",
+ *     name: "component_A",
+ *     tabSelector: "tab-component_A",
+ *     topic: "openfin-DOM-event",
+ *     type: "layout-state-changed",
+ *     uuid: "OpenFin POC"
+ * }
+ * ```
+ *
+ * #### tab-closed
+ * Generated when a tab is closed.
+ * ```js
+ * // The response has the following shape in event.detail:
+ * {
+ *     containerSelector: "container-component_A",
+ *     name: "component_A",
+ *     tabSelector: "tab-component_A",
+ *     topic: "openfin-DOM-event",
+ *     type: "tab-closed",
+ *     uuid: "OpenFin POC",
+ *     url: "http://openfin.co"   // The url of the view that was closed.
+ * }
+ * ```
+ *
+ * #### tab-dropped
+ * Generated when a tab is dropped.
+ * ```js
+ * // The response has the following shape in event.detail:
+ * {
+ *     containerSelector: "container-component_A",
+ *     name: "component_A",
+ *     tabSelector: "tab-component_A",
+ *     topic: "openfin-DOM-event",
+ *     type: "tab-dropped",
+ *     uuid: "OpenFin POC",
+ *     url: "http://openfin.co"    // The url of the view linked to the dropped tab.
+ * }
+ * ```
+ */
+class Layout extends base_1$5.Base {
+    /**
+     * @internal
+     */
+    // eslint-disable-next-line no-shadow
+    constructor(identity, wire) {
+        super(wire);
+        /**
+         * @internal
+         * Lazily constructed {@link LayoutEntitiesClient} bound to this platform's client and identity
+         * The client is for {@link LayoutEntitiesController}
+         */
+        _Layout_layoutClient.set(this, new lazy_1.Lazy(async () => layout_entities_1.LayoutNode.newLayoutEntitiesClient(await this.platform.getClient(), layout_constants_1$1.LAYOUT_CONTROLLER_ID, this.identity)));
+        /**
+         * Replaces a Platform window's layout with a new layout.
+         *
+         * @remarks Any views that were in the old layout but not the new layout will be destroyed. Views will be assigned a randomly generated name to avoid collisions.
+         * @example
+         * ```js
+         * let windowIdentity;
+         * if (fin.me.isWindow) {
+         *     windowIdentity = fin.me.identity;
+         * } else if (fin.me.isView) {
+         *     windowIdentity = (await fin.me.getCurrentWindow()).identity;
+         * } else {
+         *     throw new Error('Not running in a platform View or Window');
+         * }
+         *
+         * const layout = fin.Platform.Layout.wrapSync(windowIdentity);
+         *
+         * const newLayout = {
+         *     content: [
+         *         {
+         *             type: 'stack',
+         *             content: [
+         *                 {
+         *                     type: 'component',
+         *                     componentName: 'view',
+         *                     componentState: {
+         *                         name: 'new_component_A1',
+         *                         processAffinity: 'ps_1',
+         *                         url: 'https://www.example.com'
+         *                     }
+         *                 },
+         *                 {
+         *                     type: 'component',
+         *                     componentName: 'view',
+         *                     componentState: {
+         *                         name: 'new_component_A2',
+         *                         url: 'https://cdn.openfin.co/embed-web/chart.html'
+         *                     }
+         *                 }
+         *             ]
+         *         }
+         *     ]
+         * };
+         *
+         * layout.replace(newLayout);
+         * ```
+         */
+        this.replace = async (layout) => {
+            this.wire.sendAction('layout-replace').catch((e) => {
+                // don't expose
+            });
+            const client = await this.platform.getClient();
+            await client.dispatch('replace-layout', {
+                target: this.identity,
+                opts: { layout }
+            });
+        };
+        /**
+         * Replaces the specified view with a view with the provided configuration.
+         *
+         * @remarks The old view is stripped of its listeners and either closed or attached to the provider window
+         * depending on `detachOnClose` view option.
+         *
+         * @param viewToReplace Identity of the view to be replaced
+         * @param newView Creation options of the new view.
+         *
+         * @example
+         * ```js
+         * let currentWindow;
+         * if (fin.me.isWindow) {
+         *     currentWindow = fin.me;
+         * } else if (fin.me.isView) {
+         *     currentWindow = await fin.me.getCurrentWindow();
+         * } else {
+         *     throw new Error('Not running in a platform View or Window');
+         * }
+         *
+         * const layout = fin.Platform.Layout.wrapSync(currentWindow.identity);
+         * const viewToReplace = (await currentWindow.getCurrentViews())[0];
+         * const newViewConfig = {url: 'https://example.com'};
+         * await layout.replaceView(viewToReplace.identity, newViewConfig);
+         * ```
+         */
+        this.replaceView = async (viewToReplace, newView) => {
+            this.wire.sendAction('layout-replace-view').catch((e) => {
+                // don't expose
+            });
+            const client = await this.platform.getClient();
+            await client.dispatch('replace-view', {
+                target: this.identity,
+                opts: { viewToReplace, newView }
+            });
+        };
+        /**
+         * Replaces a Platform window's layout with a preset layout arrangement using the existing Views attached to the window.
+         * The preset options are `columns`, `grid`, `rows`, and `tabs`.
+         * @param options Mandatory object with `presetType` property that sets which preset layout arrangement to use.
+         * The preset options are `columns`, `grid`, `rows`, and `tabs`.
+         *
+         * @example
+         * ```js
+         * let windowIdentity;
+         * if (fin.me.isWindow) {
+         *     windowIdentity = fin.me.identity;
+         * } else if (fin.me.isView) {
+         *     windowIdentity = (await fin.me.getCurrentWindow()).identity;
+         * } else {
+         *     throw new Error('Not running in a platform View or Window');
+         * }
+         *
+         * const layout = fin.Platform.Layout.wrapSync(windowIdentity);
+         * await layout.applyPreset({ presetType: 'grid' });
+         *
+         * // wait 5 seconds until you change the layout from grid to tabs
+         * await new Promise (res => setTimeout(res, 5000));
+         * await layout.applyPreset({ presetType: 'tabs' });
+         * ```
+         */
+        this.applyPreset = async (options) => {
+            this.wire.sendAction('layout-apply-preset').catch((e) => {
+                // don't expose
+            });
+            const client = await this.platform.getClient();
+            const { presetType } = options;
+            if (!presetType || !(0, common_utils_1.isValidPresetType)(presetType)) {
+                throw new Error('Cannot apply preset layout, please include an applicable presetType property in the PresetLayoutOptions.');
+            }
+            await client.dispatch('apply-preset-layout', {
+                target: this.identity,
+                opts: { presetType }
+            });
+        };
+        const errorMsg = (0, validate_1.validateIdentity)(identity);
+        if (errorMsg) {
+            throw new Error(errorMsg);
+        }
+        this.identity = identity;
+        this.platform = this.fin.Platform.wrapSync({ uuid: identity.uuid });
+        if (identity.uuid === this.fin.me.uuid && identity.name === this.fin.me.name) {
+            this.init = this.fin.Platform.Layout.init;
+        }
+    }
+    /**
+     * Returns the configuration of the window's layout.  Returns the same information that is returned for all windows in getSnapshot.
+     *
+     * @remarks Cannot be called from a View.
+     *
+     *
+     * @example
+     * ```js
+     * const layout = fin.Platform.Layout.getCurrentSync();
+     * // Use wrapped instance to get the layout configuration of the current window's Layout:
+     * const layoutConfig = await layout.getConfig();
+     * ```
+     */
+    async getConfig() {
+        this.wire.sendAction('layout-get-config').catch((e) => {
+            // don't expose
+        });
+        const client = await this.platform.getClient();
+        return client.dispatch('get-frame-snapshot', {
+            target: this.identity
+        });
+    }
+    /**
+     * Retrieves the attached views in current window layout.
+     *
+     * @example
+     * ```js
+     * const layout = fin.Platform.Layout.getCurrentSync();
+     * const views = await layout.getCurrentViews();
+     * ```
+     */
+    async getCurrentViews() {
+        this.wire.sendAction('layout-get-views').catch((e) => {
+            // don't expose
+        });
+        const client = await this.platform.getClient();
+        const viewIdentities = await client.dispatch('get-layout-views', {
+            target: this.identity
+        });
+        return viewIdentities.map((identity) => this.fin.View.wrapSync(identity));
+    }
+    /**
+     * Retrieves the top level content item of the layout.
+     *
+     * @remarks Cannot be called from a view.
+     *
+     *
+     *
+     * @example
+     * ```js
+     * if (!fin.me.isWindow) {
+     *     throw new Error('Not running in a platform View.');
+     * }
+     *
+     * // From the layout window
+     * const layout = fin.Platform.Layout.getCurrentSync();
+     * // Retrieves the ColumnOrRow instance
+     * const rootItem = await layout.getRootItem();
+     * const content = await rootItem.getContent();
+     * console.log(`The root ColumnOrRow instance has ${content.length} item(s)`);
+     * ```
+     */
+    async getRootItem() {
+        this.wire.sendAction('layout-get-root-item').catch(() => {
+            // don't expose
+        });
+        const client = await __classPrivateFieldGet$4(this, _Layout_layoutClient, "f").getValue();
+        const root = await client.getRoot('layoutName' in this.identity ? this.identity : undefined);
+        return layout_entities_1.LayoutNode.getEntity(root, client);
+    }
+}
+Instance$1.Layout = Layout;
+_Layout_layoutClient = new WeakMap();
+
+var __classPrivateFieldGet$3 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet$3 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _LayoutModule_instances, _LayoutModule_layoutInitializationAttempted, _LayoutModule_layoutManager, _LayoutModule_getLayoutManagerSpy, _LayoutModule_getSafeLayoutManager;
+Object.defineProperty(Factory$2, "__esModule", { value: true });
+Factory$2.LayoutModule = void 0;
+const base_1$4 = base;
+const Instance_1$2 = Instance$1;
+const layout_constants_1 = layout_constants;
+/**
+ * Static namespace for OpenFin API methods that interact with the {@link Layout} class, available under `fin.Platform.Layout`.
+ */
+class LayoutModule extends base_1$4.Base {
+    constructor() {
+        super(...arguments);
+        _LayoutModule_instances.add(this);
+        _LayoutModule_layoutInitializationAttempted.set(this, false);
+        _LayoutModule_layoutManager.set(this, null);
+        /**
+         * Initialize the window's Layout.
+         *
+         * @remarks Must be called from a custom window that has a 'layout' option set upon creation of that window.
+         * If a containerId is not provided, this method attempts to find an element with the id `layout-container`.
+         * A Layout will emit events locally on the DOM element representing the layout-container.
+         * In order to capture the relevant events during Layout initiation, set up the listeners on the DOM element prior to calling `init`.
+         * @param options - Layout init options.
+         *
+         * @experimental
+         *
+         * @example
+         * ```js
+         * // If no options are included, the layout in the window options is initialized in an element with the id `layout-container`
+         * const layout = await fin.Platform.Layout.init();
+         * ```
+         * 

+         *
+         * ```js
+         * const containerId = 'my-custom-container-id';
+         *
+         * const myLayoutContainer = document.getElementById(containerId);
+         *
+         * myLayoutContainer.addEventListener('tab-created', function(event) {
+         *     const { tabSelector } = event.detail;
+         *     const tabElement = document.getElementById(tabSelector);
+         *     const existingColor = tabElement.style.backgroundColor;
+         *     tabElement.style.backgroundColor = "red";
+         *     setTimeout(() => {
+         *         tabElement.style.backgroundColor = existingColor;
+         *     }, 2000);
+         * });
+         *
+         * // initialize the layout into an existing HTML element with the div `my-custom-container-id`
+         * // the window must have been created with a layout in its window options
+         * const layout = await fin.Platform.Layout.init({ containerId });
+         * ```
+         */
+        this.init = async (options = {}) => {
+            this.wire.sendAction('layout-init').catch((e) => {
+                // don't expose
+            });
+            if (!this.wire.environment.layoutAllowedInContext(this.fin)) {
+                throw new Error('Layout.init can only be called from a Window context.');
+            }
+            if (__classPrivateFieldGet$3(this, _LayoutModule_layoutInitializationAttempted, "f")) {
+                throw new Error('Layout.init was already called, please use Layout.create to add additional layouts.');
+            }
+            if (this.wire.environment.type === 'openfin') {
+                // preload the client
+                await this.fin.Platform.getCurrentSync().getClient();
+            }
+            __classPrivateFieldSet$3(this, _LayoutModule_layoutInitializationAttempted, true, "f");
+            // TODO: rename to createLayoutManager
+            __classPrivateFieldSet$3(this, _LayoutModule_layoutManager, await this.wire.environment.initLayoutManager(this.fin, this.wire, options), "f");
+            await this.wire.environment.applyLayoutSnapshot(this.fin, __classPrivateFieldGet$3(this, _LayoutModule_layoutManager, "f"), options);
+            const meIdentity = { name: this.fin.me.name, uuid: this.fin.me.uuid };
+            if (!options.layoutManagerOverride) {
+                // CORE-1081 to be removed when we actually delete the `layoutManager` prop
+                // in single-layout case, we return the undocumented layoutManager type
+                const layoutIdentity = { layoutName: layout_constants_1.DEFAULT_LAYOUT_KEY, ...meIdentity };
+                return __classPrivateFieldGet$3(this, _LayoutModule_getLayoutManagerSpy, "f").call(this, layoutIdentity);
+            }
+            return this.wrapSync(meIdentity);
+        };
+        _LayoutModule_getLayoutManagerSpy.set(this, (layoutIdentity) => {
+            const msg = '[Layout] You are using a deprecated property `layoutManager` - it will throw if you access it starting in v37.';
+            const managerProxy = new Proxy({}, {
+                get(target, key) {
+                    console.warn(`[Layout-mgr-proxy] accessing ${key.toString()}`);
+                    throw new Error(msg);
+                }
+            });
+            const layout = Object.assign(this.wrapSync(layoutIdentity), { layoutManager: managerProxy });
+            const layoutProxy = new Proxy(layout, {
+                get(target, key) {
+                    if (key === 'layoutManager') {
+                        console.warn(`[Layout-proxy] accessing ${key.toString()}`);
+                        throw new Error(msg);
+                    }
+                    return target[key];
+                }
+            });
+            return layoutProxy;
+        });
+        /**
+         * Returns the layout manager for the current window
+         * @returns
+         */
+        this.getCurrentLayoutManagerSync = () => {
+            return __classPrivateFieldGet$3(this, _LayoutModule_instances, "m", _LayoutModule_getSafeLayoutManager).call(this, `fin.Platform.Layout.getCurrentLayoutManagerSync()`);
+        };
+        this.create = async (options) => {
+            return this.wire.environment.createLayout(__classPrivateFieldGet$3(this, _LayoutModule_instances, "m", _LayoutModule_getSafeLayoutManager).call(this, `fin.Platform.Layout.create()`), options);
+        };
+        this.destroy = async (layoutIdentity) => {
+            return this.wire.environment.destroyLayout(__classPrivateFieldGet$3(this, _LayoutModule_instances, "m", _LayoutModule_getSafeLayoutManager).call(this, `fin.Platform.Layout.destroy()`), layoutIdentity);
+        };
+    }
+    /**
+     * Asynchronously returns a Layout object that represents a Window's layout.
+     *
+     * @example
+     * ```js
+     * let windowIdentity;
+     * if (!fin.me.isWindow) {
+     *     windowIdentity = fin.me.identity;
+     * } else if (fin.me.isView) {
+     *     windowIdentity = (await fin.me.getCurrentWindow()).identity;
+     * } else {
+     *     throw new Error('Not running in a platform View or Window');
+     * }
+     *
+     * const layout = await fin.Platform.Layout.wrap(windowIdentity);
+     * // Use wrapped instance to control layout, e.g.:
+     * const layoutConfig = await layout.getConfig();
+     * ```
+     */
+    async wrap(identity) {
+        this.wire.sendAction('layout-wrap').catch((e) => {
+            // don't expose
+        });
+        return new Instance_1$2.Layout(identity, this.wire);
+    }
+    /**
+     * Synchronously returns a Layout object that represents a Window's layout.
+     *
+     * @example
+     * ```js
+     * let windowIdentity;
+     * if (!fin.me.isWindow) {
+     *     windowIdentity = fin.me.identity;
+     * } else if (fin.me.isView) {
+     *     windowIdentity = (await fin.me.getCurrentWindow()).identity;
+     * } else {
+     *     throw new Error('Not running in a platform View or Window');
+     * }
+     *
+     * const layout = fin.Platform.Layout.wrapSync(windowIdentity);
+     * // Use wrapped instance to control layout, e.g.:
+     * const layoutConfig = await layout.getConfig();
+     * ```
+     */
+    wrapSync(identity) {
+        this.wire.sendAction('layout-wrap-sync').catch((e) => {
+            // don't expose
+        });
+        return new Instance_1$2.Layout(identity, this.wire);
+    }
+    /**
+     * Asynchronously returns a Layout object that represents a Window's layout.
+     *
+     * @example
+     * ```js
+     * const layout = await fin.Platform.Layout.getCurrent();
+     * // Use wrapped instance to control layout, e.g.:
+     * const layoutConfig = await layout.getConfig();
+     * ```
+     */
+    async getCurrent() {
+        this.wire.sendAction('layout-get-current').catch((e) => {
+            // don't expose
+        });
+        if (!this.fin.me.isWindow) {
+            throw new Error('You are not in a Window context.  Only Windows can have a Layout.');
+        }
+        const { uuid, name } = this.fin.me;
+        return this.wrap({ uuid, name });
+    }
+    /**
+     * Synchronously returns a Layout object that represents a Window's layout.
+     *
+     * @remarks Cannot be called from a view.
+     *
+     *
+     * @example
+     * ```js
+     * const layout = fin.Platform.Layout.getCurrentSync();
+     * // Use wrapped instance to control layout, e.g.:
+     * const layoutConfig = await layout.getConfig();
+     * ```
+     */
+    getCurrentSync() {
+        this.wire.sendAction('layout-get-current-sync').catch((e) => {
+            // don't expose
+        });
+        if (!this.fin.me.isWindow) {
+            throw new Error('You are not in a Window context.  Only Windows can have a Layout.');
+        }
+        const { uuid, name } = this.fin.me;
+        return this.wrapSync({ uuid, name });
+    }
+}
+Factory$2.LayoutModule = LayoutModule;
+_LayoutModule_layoutInitializationAttempted = new WeakMap(), _LayoutModule_layoutManager = new WeakMap(), _LayoutModule_getLayoutManagerSpy = new WeakMap(), _LayoutModule_instances = new WeakSet(), _LayoutModule_getSafeLayoutManager = function _LayoutModule_getSafeLayoutManager(method) {
+    if (!__classPrivateFieldGet$3(this, _LayoutModule_layoutManager, "f")) {
+        throw new Error(`You must call init before using the API ${method}`);
+    }
+    return __classPrivateFieldGet$3(this, _LayoutModule_layoutManager, "f");
+};
+
+(function (exports) {
+	/**
+	 * Entry point for the OpenFin `Layout` subset of the `Platform` API (`fin.Platform.Layout`).
+	 *
+	 * * {@link LayoutModule} contains static members of the `Layout` API, accessible through `fin.Platform.Layout`.
+	 * * {@link Layout} describes an instance of an OpenFin Layout, e.g. as returned by `fin.Platform.Layout.getCurrent`.
+	 *
+	 * These are separate code entities, and are documented separately. In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/32.114.76.10/index.html),
+	 * both of these were documented on the same page.
+	 *
+	 * @packageDocumentation
+	 *
+	 */
+	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    var desc = Object.getOwnPropertyDescriptor(m, k);
+	    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+	      desc = { enumerable: true, get: function() { return m[k]; } };
+	    }
+	    Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    o[k2] = m[k];
+	}));
+	var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	__exportStar(Factory$2, exports);
+	__exportStar(Instance$1, exports); 
+} (layout));
+
+Object.defineProperty(Factory$3, "__esModule", { value: true });
+Factory$3.PlatformModule = void 0;
+const base_1$3 = base;
+const Instance_1$1 = Instance$2;
+const index_1$1 = layout;
+/**
+ * Static namespace for OpenFin API methods that interact with the {@link Platform} class, available under `fin.Platform`.
+ */
+class PlatformModule extends base_1$3.Base {
+    /**
+     * @internal
+     */
+    constructor(wire, channel) {
+        super(wire);
+        this._channel = channel;
+        /**
+         *
+         * @desc Layouts give app providers the ability to embed multiple views in a single window.  The Layout namespace
+         * enables the initialization and manipulation of a window's Layout.  A Layout will
+         * emit events locally on the DOM element representing the layout-container.
+         */
+        this.Layout = new index_1$1.LayoutModule(this.wire);
+    }
+    /**
+     * Initializes a Platform. Must be called from the Provider when using a custom provider.
+     * @param options - platform options including a callback function that can be used to extend or replace
+     * default Provider behavior.
+     *
+     * @remarks Must be called from the Provider when using a custom provider.
+     *
+     * @example
+     *
+     * ```js
+     * // From Provider context
+     * await fin.Platform.init();
+     * // Platform API is now hooked up and windows contained in the manifest snapshot are open.
+     * ```
+     *
+     * `Platform.init` accepts an options object that can contain a callback function which can be used to extend or
+     * replace default Provider behavior. As an argument, this function will receive the `Provider` class, which is
+     * used to handle Platform actions. The function must return an object with methods to handle Platform API actions.
+     * The recommended approach is to extend the `Provider` class, overriding the methods you wish to alter, and return an
+     * instance of your subclass:
+     *
+     * ```js
+     * const overrideCallback = async (PlatformProvider) => {
+     *     // Actions can be performed before initialization.
+     *     // e.g. we might authenticate a user, set up a Channel, etc before initializing the Platform.
+     *     const { manifestUrl } = await fin.Application.getCurrentSync().getInfo();
+     *
+     *     // Extend or replace default PlatformProvider behavior by extending the PlatformProvider class.
+     *     class MyOverride extends PlatformProvider {
+     *         // Default behavior can be changed by implementing methods with the same names as those used by the default PlatformProvider.
+     *         async getSnapshot() {
+     *             // Since we are extending the class, we can call `super` methods to access default behavior.
+     *             const snapshot = await super.getSnapshot();
+     *             // But we can modify return values.
+     *             return { ...snapshot, answer: 42, manifestUrl };
+     *         }
+     *         async replaceLayout({ opts, target }) {
+     *             // To disable an API method, overwrite with a noop function.
+     *             return;
+     *         }
+     *     }
+     *     // Return instance with methods to be consumed by Platform.
+     *     // The returned object must implement all methods of the PlatformProvider class.
+     *     // By extending the class, we can simply inherit methods we do not wish to alter.
+     *     return new MyOverride();
+     * };
+     *
+     * fin.Platform.init({overrideCallback});
+     * ```
+     * @experimental
+     */
+    async init(options) {
+        if (!fin.__internal_.isPlatform || fin.me.name !== fin.me.uuid) {
+            throw new Error('fin.Platform.init should only be called from a custom platform provider running in the main window of the application.');
+        }
+        return this.wire.environment.initPlatform(this.fin, options);
+    }
+    /**
+     * Asynchronously returns a Platform object that represents an existing platform.
+     *
+     * @example
+     * ```js
+     * const { identity } = fin.me;
+     * const platform = await fin.Platform.wrap(identity);
+     * // Use wrapped instance to control layout, e.g.:
+     * const snapshot = await platform.getSnapshot();
+     * ```
+     */
+    async wrap(identity) {
+        this.wire.sendAction('platform-wrap').catch((e) => {
+            // don't expose
+        });
+        return new Instance_1$1.Platform({ uuid: identity.uuid }, this._channel);
+    }
+    /**
+     * Synchronously returns a Platform object that represents an existing platform.
+     *
+     * @example
+     * ```js
+     * const { identity } = fin.me;
+     * const platform = fin.Platform.wrapSync(identity);
+     * // Use wrapped instance to control layout, e.g.:
+     * const snapshot = await platform.getSnapshot();
+     * ```
+     */
+    wrapSync(identity) {
+        this.wire.sendAction('platform-wrap-sync').catch((e) => {
+            // don't expose
+        });
+        return new Instance_1$1.Platform({ uuid: identity.uuid }, this._channel);
+    }
+    /**
+     * Asynchronously returns a Platform object that represents the current platform.
+     *
+     * @example
+     * ```js
+     * const platform = await fin.Platform.getCurrent();
+     * // Use wrapped instance to control layout, e.g.:
+     * const snapshot = await platform.getSnapshot();
+     * ```
+     */
+    async getCurrent() {
+        this.wire.sendAction('platform-get-current').catch((e) => {
+            // don't expose
+        });
+        return this.wrap({ uuid: this.wire.me.uuid });
+    }
+    /**
+     * Synchronously returns a Platform object that represents the current platform.
+     *
+     * @example
+     * ```js
+     * const platform = fin.Platform.getCurrentSync();
+     * // Use wrapped instance to control layout, e.g.:
+     * const snapshot = await platform.getSnapshot();
+     * ```
+     */
+    getCurrentSync() {
+        this.wire.sendAction('platform-get-current-sync').catch((e) => {
+            // don't expose
+        });
+        return this.wrapSync({ uuid: this.wire.me.uuid });
+    }
+    /**
+     * Creates and starts a Platform and returns a wrapped and running Platform instance. The wrapped Platform methods can
+     * be used to launch content into the platform.  Promise will reject if the platform is already running.
+     *
+     * @example
+     * ```js
+     * try {
+     *     const platform = await fin.Platform.start({
+     *         uuid: 'platform-1',
+     *         autoShow: false,
+     *         defaultWindowOptions: {
+     *             stylesheetUrl: 'css-sheet-url',
+     *             cornerRounding: {
+     *                 height: 10,
+     *                 width: 10
+     *             }
+     *         }
+     *     });
+     *     console.log('Platform is running', platform);
+     * } catch(e) {
+     *     console.error(e);
+     * }
+     * ```
+     */
+    start(platformOptions) {
+        this.wire.sendAction('platform-start').catch((e) => {
+            // don't expose
+        });
+        // eslint-disable-next-line no-async-promise-executor
+        return new Promise(async (resolve, reject) => {
+            try {
+                const { uuid } = platformOptions;
+                // @ts-expect-error using private variable.
+                const app = await this.fin.Application._create({ ...platformOptions, isPlatformController: true });
+                // TODO: fix typing (internal)
+                // @ts-expect-error
+                app.once('platform-api-ready', () => resolve(this.wrapSync({ uuid })));
+                // @ts-expect-error using private variable.
+                app._run({ uuid });
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+    }
+    /**
+     * Retrieves platforms's manifest and returns a wrapped and running Platform.  If there is a snapshot in the manifest,
+     * it will be launched into the platform.
+     * @param manifestUrl - The URL of platform's manifest.
+     * @param opts - Parameters that the RVM will use.
+     *
+     * @example
+     * ```js
+     * try {
+     *     const platform = await fin.Platform.startFromManifest('https://openfin.github.io/golden-prototype/public.json');
+     *     console.log('Platform is running, wrapped platform: ', platform);
+     * } catch(e) {
+     *     console.error(e);
+     * }
+     * // For a local manifest file:
+     * try {
+     *     const platform = await fin.Platform.startFromManifest('file:///C:/somefolder/app.json');
+     *     console.log('Platform is running, wrapped platform: ', platform);
+     * } catch(e) {
+     *     console.error(e);
+     * }
+     * ```
+     */
+    startFromManifest(manifestUrl, opts) {
+        this.wire.sendAction('platform-start-from-manifest').catch((e) => {
+            // don't expose
+        });
+        // eslint-disable-next-line no-async-promise-executor
+        return new Promise(async (resolve, reject) => {
+            try {
+                // @ts-expect-error using private variable.
+                const app = await this.fin.Application._createFromManifest(manifestUrl);
+                // TODO: fix typing (internal)
+                // @ts-expect-error
+                app.once('platform-api-ready', () => resolve(this.wrapSync({ uuid: app.identity.uuid })));
+                // @ts-expect-error using private method without warning.
+                app._run(opts);
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+    }
+}
+Factory$3.PlatformModule = PlatformModule;
+
+(function (exports) {
+	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    var desc = Object.getOwnPropertyDescriptor(m, k);
+	    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+	      desc = { enumerable: true, get: function() { return m[k]; } };
+	    }
+	    Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    o[k2] = m[k];
+	}));
+	var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	/**
+	 * Entry points for the OpenFin `Platform` API (`fin.Platform`)
+	 *
+	 * * {@link PlatformModule} contains static members of the `Platform` API, accessible through `fin.Platform`.
+	 * * {@link Platform} describes an instance of an OpenFin Platform, e.g. as returned by `fin.Platform.getCurrent`.
+	 *
+	 * These are separate code entities, and are documented separately.  In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/32.114.76.10/index.html),
+	 * both of these were documented on the same page.
+	 *
+	 * @packageDocumentation
+	 */
+	__exportStar(Factory$3, exports);
+	__exportStar(Instance$2, exports); 
+} (platform));
+
+var me = {};
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.getMe = exports.getBaseMe = exports.environmentUnsupportedMessage = void 0;
+	const view_1 = requireView();
+	const frame_1 = frame;
+	const window_1 = requireWindow();
+	const external_application_1 = externalApplication;
+	exports.environmentUnsupportedMessage = 'You are not running in OpenFin.';
+	function getBaseMe(entityType, uuid, name) {
+	    const entityTypeHelpers = {
+	        isView: entityType === 'view',
+	        isWindow: entityType === 'window',
+	        isFrame: entityType === 'iframe',
+	        isExternal: entityType === 'external connection'
+	    };
+	    return { ...entityTypeHelpers, uuid, name, entityType };
+	}
+	exports.getBaseMe = getBaseMe;
+	// We need to do a lot of casting as unknown here because the compiler get's confused about matching types. What matters is that it works on the outside
+	function getMe(wire) {
+	    const { uuid, name, entityType } = wire.me;
+	    const unsupportedInterop = {
+	        setContext() {
+	            throw new Error(exports.environmentUnsupportedMessage);
+	        },
+	        addContextHandler() {
+	            throw new Error(exports.environmentUnsupportedMessage);
+	        },
+	        getContextGroups() {
+	            throw new Error(exports.environmentUnsupportedMessage);
+	        },
+	        joinContextGroup() {
+	            throw new Error(exports.environmentUnsupportedMessage);
+	        },
+	        removeFromContextGroup() {
+	            throw new Error(exports.environmentUnsupportedMessage);
+	        },
+	        getAllClientsInContextGroup() {
+	            throw new Error(exports.environmentUnsupportedMessage);
+	        },
+	        getInfoForContextGroup() {
+	            throw new Error(exports.environmentUnsupportedMessage);
+	        }
+	    };
+	    const fallbackErrorMessage = 'Interop API has not been instantiated. Either connection has failed or you have not declared interop in your config.';
+	    const fallbackInterop = {
+	        setContext() {
+	            throw new Error(fallbackErrorMessage);
+	        },
+	        addContextHandler() {
+	            throw new Error(fallbackErrorMessage);
+	        },
+	        getContextGroups() {
+	            throw new Error(fallbackErrorMessage);
+	        },
+	        joinContextGroup() {
+	            throw new Error(fallbackErrorMessage);
+	        },
+	        removeFromContextGroup() {
+	            throw new Error(fallbackErrorMessage);
+	        },
+	        getAllClientsInContextGroup() {
+	            throw new Error(fallbackErrorMessage);
+	        },
+	        getInfoForContextGroup() {
+	            throw new Error(fallbackErrorMessage);
+	        }
+	    };
+	    const unsupportedEventBase = {
+	        eventNames: () => {
+	            throw new Error(exports.environmentUnsupportedMessage);
+	        },
+	        emit: () => {
+	            throw new Error(exports.environmentUnsupportedMessage);
+	        },
+	        listeners: () => {
+	            throw new Error(exports.environmentUnsupportedMessage);
+	        },
+	        listenerCount: () => {
+	            throw new Error(exports.environmentUnsupportedMessage);
+	        },
+	        on: () => {
+	            throw new Error(exports.environmentUnsupportedMessage);
+	        },
+	        addListener: () => {
+	            throw new Error(exports.environmentUnsupportedMessage);
+	        },
+	        once: () => {
+	            throw new Error(exports.environmentUnsupportedMessage);
+	        },
+	        prependListener: () => {
+	            throw new Error(exports.environmentUnsupportedMessage);
+	        },
+	        prependOnceListener: () => {
+	            throw new Error(exports.environmentUnsupportedMessage);
+	        },
+	        removeListener: () => {
+	            throw new Error(exports.environmentUnsupportedMessage);
+	        },
+	        removeAllListeners: () => {
+	            throw new Error(exports.environmentUnsupportedMessage);
+	        }
+	    };
+	    switch (entityType) {
+	        case 'view':
+	            return Object.assign(new view_1.View(wire, { uuid, name }), getBaseMe(entityType, uuid, name), {
+	                interop: fallbackInterop,
+	                isOpenFin: true
+	            });
+	        case 'window':
+	            return Object.assign(new window_1._Window(wire, { uuid, name }), getBaseMe(entityType, uuid, name), {
+	                interop: fallbackInterop,
+	                isOpenFin: true
+	            });
+	        case 'iframe':
+	            return Object.assign(new frame_1._Frame(wire, { uuid, name }), getBaseMe(entityType, uuid, name), {
+	                interop: fallbackInterop,
+	                isOpenFin: true
+	            });
+	        case 'external connection':
+	            return Object.assign(new external_application_1.ExternalApplication(wire, { uuid }), getBaseMe(entityType, uuid, name), {
+	                interop: fallbackInterop,
+	                isOpenFin: false
+	            });
+	        default:
+	            return {
+	                ...getBaseMe(entityType, uuid, name),
+	                ...unsupportedEventBase,
+	                interop: unsupportedInterop,
+	                isOpenFin: false
+	            };
+	    }
+	}
+	exports.getMe = getMe; 
+} (me));
+
+var interop = {};
+
+var Factory$1 = {};
+
+var inaccessibleObject = {};
+
+Object.defineProperty(inaccessibleObject, "__esModule", { value: true });
+inaccessibleObject.createWarningObject = inaccessibleObject.createUnusableObject = void 0;
+function createUnusableObject(message) {
+    const handle = () => {
+        throw new Error(message);
+    };
+    return new Proxy({}, {
+        apply: handle,
+        construct: handle,
+        defineProperty: handle,
+        deleteProperty: handle,
+        get: handle,
+        getOwnPropertyDescriptor: handle,
+        getPrototypeOf: handle,
+        has: handle,
+        isExtensible: handle,
+        ownKeys: handle,
+        preventExtensions: handle,
+        set: handle,
+        setPrototypeOf: handle
+    });
+}
+inaccessibleObject.createUnusableObject = createUnusableObject;
+function createWarningObject(message, obj) {
+    return new Proxy(obj, {
+        get: (...args) => {
+            // eslint-disable-next-line no-console
+            console.warn(message);
+            return Reflect.get(...args);
+        },
+        set: (...args) => {
+            // eslint-disable-next-line no-console
+            console.warn(message);
+            return Reflect.set(...args);
+        },
+        getOwnPropertyDescriptor: (...args) => {
+            // eslint-disable-next-line no-console
+            console.warn(message);
+            return Reflect.getOwnPropertyDescriptor(...args);
+        },
+        ownKeys: (...args) => {
+            // eslint-disable-next-line no-console
+            console.warn(message);
+            return Reflect.ownKeys(...args);
+        }
+    });
+}
+inaccessibleObject.createWarningObject = createWarningObject;
+
+var InteropBroker = {};
+
+var SessionContextGroupBroker = {};
+
+var hasRequiredSessionContextGroupBroker;
+
+function requireSessionContextGroupBroker () {
+	if (hasRequiredSessionContextGroupBroker) return SessionContextGroupBroker;
+	hasRequiredSessionContextGroupBroker = 1;
+	Object.defineProperty(SessionContextGroupBroker, "__esModule", { value: true });
+	const _1 = requireInterop();
+	let SessionContextGroupBroker$1 = class SessionContextGroupBroker {
+	    constructor(provider, id) {
+	        this.provider = provider;
+	        this.id = id;
+	        this.lastContext = undefined;
+	        this.contextGroupMap = new Map();
+	        this.clients = new Map();
+	        this.registerListeners();
+	    }
+	    registerListeners() {
+	        this.provider.register(`sessionContextGroup:getContext-${this.id}`, this.getCurrentContext.bind(this));
+	        this.provider.register(`sessionContextGroup:setContext-${this.id}`, this.setContext.bind(this));
+	        this.provider.register(`sessionContextGroup:handlerAdded-${this.id}`, this.handlerAdded.bind(this));
+	        this.provider.register(`sessionContextGroup:handlerRemoved-${this.id}`, this.handlerRemoved.bind(this));
+	    }
+	    getCurrentContext(payload) {
+	        return payload.type ? this.contextGroupMap.get(payload.type) : this.lastContext;
+	    }
+	    setContext(payload, clientIdentity) {
+	        const { context } = payload;
+	        const contextIntegrityCheckResult = _1.InteropBroker.checkContextIntegrity(context);
+	        if (contextIntegrityCheckResult.isValid === false) {
+	            throw new Error(`Failed to set Context - bad Context. Reason: ${contextIntegrityCheckResult.reason}. Context: ${JSON.stringify(context)}`);
+	        }
+	        const clientState = this.getClientState(clientIdentity);
+	        if (!clientState) {
+	            // This shouldn't get hit.
+	            throw new Error(`Client with Identity: ${clientIdentity.uuid} ${clientIdentity.name} not in Session Client State Map`);
+	        }
+	        // set the context
+	        this.contextGroupMap.set(context.type, context);
+	        this.lastContext = context;
+	        const clientSubscriptionStates = Array.from(this.clients.values());
+	        clientSubscriptionStates.forEach((client) => {
+	            // eslint-disable-next-line no-unused-expressions
+	            client.contextHandlers.get(context.type)?.forEach((handlerId) => {
+	                this.provider.dispatch(client.clientIdentity, handlerId, context);
+	            });
+	            if (client.globalHandler) {
+	                this.provider.dispatch(client.clientIdentity, client.globalHandler, context);
+	            }
+	        });
+	    }
+	    getClientState(id) {
+	        return this.clients.get(id.endpointId);
+	    }
+	    async handlerAdded(payload, clientIdentity) {
+	        const { handlerId, contextType } = payload;
+	        const clientSubscriptionState = this.getClientState(clientIdentity);
+	        if (!clientSubscriptionState) {
+	            throw new Error(`Client with Identity: ${clientIdentity.uuid} ${clientIdentity.name} not in Client State Map`);
+	        }
+	        if (contextType) {
+	            const currentHandlerList = clientSubscriptionState.contextHandlers.get(contextType) || [];
+	            clientSubscriptionState.contextHandlers.set(contextType, [...currentHandlerList, handlerId]);
+	            const currentContext = this.contextGroupMap.get(contextType);
+	            if (currentContext) {
+	                await this.provider.dispatch(clientIdentity, handlerId, currentContext);
+	            }
+	        }
+	        else {
+	            clientSubscriptionState.globalHandler = handlerId;
+	            const globalDispatchPromises = [...this.contextGroupMap.keys()].map(async (currentContextType) => {
+	                const currentContext = this.contextGroupMap.get(currentContextType);
+	                if (currentContext) {
+	                    await this.provider.dispatch(clientIdentity, handlerId, currentContext);
+	                }
+	            });
+	            await Promise.all(globalDispatchPromises);
+	        }
+	    }
+	    handlerRemoved(payload, clientIdentity) {
+	        const { handlerId } = payload;
+	        const client = this.clients.get(clientIdentity.endpointId);
+	        if (client) {
+	            Array.from(client.contextHandlers).forEach(([, handlers]) => {
+	                const index = handlers.indexOf(handlerId);
+	                if (index > -1) {
+	                    handlers.splice(index, 1);
+	                }
+	            });
+	            if (client.globalHandler === handlerId) {
+	                client.globalHandler = undefined;
+	            }
+	        }
+	        else {
+	            console.warn(`Trying to remove a handler from a client that isn't mapped. handlerId: ${handlerId}. clientIdentity: ${clientIdentity}`);
+	        }
+	    }
+	    registerNewClient(clientIdentity) {
+	        if (!this.clients.has(clientIdentity.endpointId)) {
+	            const clientSubscriptionState = {
+	                contextHandlers: new Map(),
+	                clientIdentity,
+	                globalHandler: undefined
+	            };
+	            this.clients.set(clientIdentity.endpointId, clientSubscriptionState);
+	        }
+	    }
+	    onDisconnection(clientIdentity) {
+	        this.clients.delete(clientIdentity.endpointId);
+	    }
+	};
+	SessionContextGroupBroker.default = SessionContextGroupBroker$1;
+	return SessionContextGroupBroker;
+}
+
+var utils$3 = {};
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.wrapIntentHandler = exports.BROKER_ERRORS = exports.generateOverrideWarning = exports.generateOverrideError = exports.wrapContextHandler = exports.wrapInTryCatch = exports.generateId = void 0;
+	const generateId = () => `${Math.random()}${Date.now()}`;
+	exports.generateId = generateId;
+	const wrapInTryCatch = (f, prefix) => (...args) => {
+	    try {
+	        return f(...args);
+	    }
+	    catch (e) {
+	        throw new Error((prefix || '') + e);
+	    }
+	};
+	exports.wrapInTryCatch = wrapInTryCatch;
+	const wrapContextHandler = (handler, handlerId) => {
+	    return async (context) => {
+	        try {
+	            await handler(context);
+	        }
+	        catch (error) {
+	            console.error(`Error thrown by handler ${handlerId} for context type ${context.type}: ${error}`);
+	            throw error;
+	        }
+	    };
+	};
+	exports.wrapContextHandler = wrapContextHandler;
+	const generateOverrideError = (clientApi, brokerApi) => {
+	    return `You have tried to to use ${clientApi} but ${brokerApi} has not been overridden in the Interop Broker. Please override this function. Refer to our documentation for more info.`;
+	};
+	exports.generateOverrideError = generateOverrideError;
+	const generateOverrideWarning = (fdc3ClientApi, brokerApi, identity, interopClientApi) => {
+	    const { uuid, name } = identity;
+	    const message = interopClientApi
+	        ? `Entity with identity: ${uuid}/${name} has called ${interopClientApi} or ${fdc3ClientApi} but ${brokerApi} has not been overridden.`
+	        : `Entity with identity: ${uuid}/${name} has called ${fdc3ClientApi} but ${brokerApi} has not been overridden.`;
+	    return message;
+	};
+	exports.generateOverrideWarning = generateOverrideWarning;
+	exports.BROKER_ERRORS = {
+	    fireIntent: (0, exports.generateOverrideError)('fireIntent', 'handleFiredIntent'),
+	    fireIntentForContext: (0, exports.generateOverrideError)('fireIntentForContext', 'handleFiredIntentForContext'),
+	    getInfoForIntent: (0, exports.generateOverrideError)('getInfoForIntent', 'handleInfoForIntent'),
+	    getInfoForIntentsByContext: (0, exports.generateOverrideError)('getInfoForIntentsByContext', 'handleInfoForIntentsByContext'),
+	    joinSessionContextGroupWithJoinContextGroup: 'The Context Group you have tried to join is a Session Context Group. Custom Context Groups can only be defined by the Interop Broker through code or manifest configuration. Please use joinSessionContextGroup.',
+	    fdc3Open: (0, exports.generateOverrideError)('fdc3.open', 'fdc3HandleOpen'),
+	    fdc3FindInstances: (0, exports.generateOverrideError)('fdc3.findInstances', 'fdc3HandleFindInstances'),
+	    fdc3GetAppMetadata: (0, exports.generateOverrideError)('fdc3.getAppMetadata', 'fdc3HandleGetAppMetadata'),
+	    fdc3GetInfo: (0, exports.generateOverrideError)('fdc3.getInfo', 'fdc3HandleGetInfo')
+	};
+	const wrapIntentHandler = (handler, handlerId) => {
+	    return async (intent) => {
+	        try {
+	            return handler(intent);
+	        }
+	        catch (error) {
+	            console.error(`Error thrown by handler ${handlerId}: ${error}`);
+	            throw error;
+	        }
+	    };
+	};
+	exports.wrapIntentHandler = wrapIntentHandler; 
+} (utils$3));
+
+var PrivateChannelProvider = {};
+
+var hasRequiredPrivateChannelProvider;
+
+function requirePrivateChannelProvider () {
+	if (hasRequiredPrivateChannelProvider) return PrivateChannelProvider;
+	hasRequiredPrivateChannelProvider = 1;
+	Object.defineProperty(PrivateChannelProvider, "__esModule", { value: true });
+	PrivateChannelProvider.PrivateChannelProvider = void 0;
+	const InteropBroker_1 = requireInteropBroker();
+	let PrivateChannelProvider$1 = class PrivateChannelProvider {
+	    constructor(provider, id) {
+	        this.provider = provider;
+	        this.id = id;
+	        this.clients = new Map();
+	        this.registerListeners();
+	        this.contextByContextType = new Map();
+	        this.lastContext = undefined;
+	        this.provider.onConnection((clientIdentity) => this.registerNewClient(clientIdentity));
+	        this.provider.onDisconnection(async (clientIdentity) => {
+	            const { endpointId } = clientIdentity;
+	            if (this.clients.has(endpointId)) {
+	                await this.handleClientDisconnecting(clientIdentity);
+	            }
+	            if ((await this.provider.getAllClientInfo()).length === 0) {
+	                this.provider.destroy();
+	            }
+	        });
+	    }
+	    getClientState(id) {
+	        return this.clients.get(id.endpointId);
+	    }
+	    registerListeners() {
+	        this.provider.register('broadcast', this.broadcast.bind(this));
+	        this.provider.register('getCurrentContext', this.getCurrentContext.bind(this));
+	        this.provider.register('contextHandlerAdded', this.contextHandlerAdded.bind(this));
+	        this.provider.register('contextHandlerRemoved', this.contextHandlerRemoved.bind(this));
+	        this.provider.register('nonStandardHandlerRemoved', this.nonStandardHandlerRemoved.bind(this));
+	        this.provider.register('onAddContextHandlerAdded', this.onAddContextHandlerAdded.bind(this));
+	        this.provider.register('onDisconnectHandlerAdded', this.onDisconnectHandlerAdded.bind(this));
+	        this.provider.register('onUnsubscribeHandlerAdded', this.onUnsubscribeHandlerAdded.bind(this));
+	        this.provider.register('clientDisconnecting', (payload, clientIdentity) => {
+	            this.handleClientDisconnecting(clientIdentity);
+	        });
+	    }
+	    broadcast(payload, broadcasterClientIdentity) {
+	        const { context } = payload;
+	        const broadcasterClientState = this.getClientState(broadcasterClientIdentity);
+	        if (!broadcasterClientState) {
+	            throw new Error(`Client with Identity: ${broadcasterClientIdentity.uuid} ${broadcasterClientIdentity.name}, tried to call broadcast, is not connected to this Private Channel`);
+	        }
+	        const contextIntegrityCheckResult = InteropBroker_1.InteropBroker.checkContextIntegrity(context);
+	        if (contextIntegrityCheckResult.isValid === false) {
+	            throw new Error(`Failed to broadcast - bad Context. Reason: ${contextIntegrityCheckResult.reason}. Context: ${JSON.stringify(context)}`);
+	        }
+	        this.contextByContextType.set(context.type, context);
+	        this.lastContext = context;
+	        Array.from(this.clients.values()).forEach((currClientState) => {
+	            const handlerIdsForContextType = currClientState.handlerIdsByContextTypes.get(context.type);
+	            if (handlerIdsForContextType) {
+	                handlerIdsForContextType.forEach((handlerId) => {
+	                    this.provider.dispatch(currClientState.clientIdentity, handlerId, context);
+	                });
+	            }
+	            if (currClientState.globalHandler) {
+	                this.provider.dispatch(currClientState.clientIdentity, currClientState.globalHandler, context);
+	            }
+	        });
+	    }
+	    getCurrentContext(payload, senderClientIdentity) {
+	        const { contextType } = payload;
+	        const clientState = this.getClientState(senderClientIdentity);
+	        if (!clientState) {
+	            throw new Error(`Client with Identity: ${senderClientIdentity.uuid} ${senderClientIdentity.name}, tried to call getCurrentContext, is not connected to this Private Channel`);
+	        }
+	        if (contextType !== undefined) {
+	            const currentContext = this.contextByContextType.get(contextType);
+	            if (currentContext)
+	                return currentContext;
+	            return null;
+	        }
+	        return this.lastContext ? this.lastContext : null;
+	    }
+	    contextHandlerAdded(payload, senderClientIdentity) {
+	        const { handlerId, contextType } = payload;
+	        const senderClientState = this.getClientState(senderClientIdentity);
+	        if (!senderClientState) {
+	            throw new Error(`Client with Identity: ${senderClientIdentity.uuid} ${senderClientIdentity.name}, tried to call addContextListener, is not connected to this Private Channel`);
+	        }
+	        if (contextType) {
+	            const currentHandlersList = senderClientState.handlerIdsByContextTypes.get(contextType) || [];
+	            senderClientState.handlerIdsByContextTypes.set(contextType, [...currentHandlersList, handlerId]);
+	        }
+	        else {
+	            senderClientState.globalHandler = handlerId;
+	        }
+	        Array.from(this.clients.values()).forEach((currClientState) => {
+	            if (currClientState.clientIdentity.endpointId !== senderClientIdentity.endpointId &&
+	                currClientState.onAddContextListenerHandlerId) {
+	                this.provider.dispatch(currClientState.clientIdentity, currClientState.onAddContextListenerHandlerId, contextType);
+	            }
+	        });
+	    }
+	    async contextHandlerRemoved(payload, removingClientIdentity) {
+	        // MC: Made this removal async to ensure that onUnsubscribe handlers are hit before anything else happens.
+	        const { handlerId } = payload;
+	        const removingClientState = this.getClientState(removingClientIdentity);
+	        if (removingClientState) {
+	            let contextType;
+	            if (removingClientState.globalHandler === handlerId) {
+	                removingClientState.globalHandler = undefined;
+	            }
+	            else {
+	                for (const [currContextType, handlersIds] of removingClientState.handlerIdsByContextTypes) {
+	                    const index = handlersIds.indexOf(handlerId);
+	                    if (index > -1) {
+	                        handlersIds.splice(index, 1);
+	                        contextType = currContextType;
+	                    }
+	                }
+	            }
+	            // getting only valid client connections here, it is possible we haven't removed a disconnected client from the map yet
+	            // so we need to ensure we don't dispatch to any disconnected client
+	            // TODO: Take a look at our client disconnection logic and see if we can handle client disconnection cleanly
+	            const clientsToDispatchTo = await this.getConnectedClients();
+	            const dispatchPromises = clientsToDispatchTo.map(async (otherClientState) => {
+	                const { clientIdentity, clientIdentity: { endpointId }, onUnsubscribeHandlerId } = otherClientState;
+	                if (endpointId !== removingClientIdentity.endpointId && onUnsubscribeHandlerId) {
+	                    await this.provider.dispatch(clientIdentity, onUnsubscribeHandlerId, contextType);
+	                }
+	            });
+	            try {
+	                await Promise.all(dispatchPromises);
+	            }
+	            catch (error) {
+	                console.error(`Problem when attempting to dispatch to onUnsubscribeHandlers. Error: ${error} Removing Client: ${handlerId}. uuid: ${removingClientIdentity.uuid}. name: ${removingClientIdentity.name}. endpointId: ${removingClientIdentity.endpointId}`);
+	                throw new Error(error);
+	            }
+	        }
+	        else {
+	            console.warn(`Trying to remove a handler from a client that isn't mapped. handlerId: ${handlerId}. uuid: ${removingClientIdentity.uuid}. name: ${removingClientIdentity.name}. endpointId: ${removingClientIdentity.endpointId}.`);
+	        }
+	    }
+	    nonStandardHandlerRemoved(payload, id) {
+	        const { handlerId } = payload;
+	        const clientState = this.getClientState(id);
+	        if (clientState) {
+	            if (clientState.onDisconnectHandlerId === handlerId) {
+	                clientState.onDisconnectHandlerId = undefined;
+	            }
+	            else if (clientState.onAddContextListenerHandlerId === handlerId) {
+	                clientState.onAddContextListenerHandlerId = undefined;
+	            }
+	            else if (clientState.onUnsubscribeHandlerId === handlerId) {
+	                clientState.onUnsubscribeHandlerId = undefined;
+	            }
+	        }
+	        else {
+	            console.warn(`Trying to remove a handler from a client that isn't mapped. handlerId: ${handlerId}. clientIdentity: ${id}`);
+	        }
+	    }
+	    onAddContextHandlerAdded(payload, senderClientIdentity) {
+	        const clientState = this.getClientState(senderClientIdentity);
+	        const { handlerId } = payload;
+	        if (!clientState) {
+	            throw new Error(`Client with Identity: ${senderClientIdentity.uuid} ${senderClientIdentity.name}, tried to call onAddContextListener, is not connected to this Private Channel`);
+	        }
+	        clientState.onAddContextListenerHandlerId = handlerId;
+	        // FDC3 Spec says that the added listener should fire for all previously-registered addContextListeners from the other client
+	        Array.from(this.clients.values()).forEach((otherClientState) => {
+	            if (otherClientState.clientIdentity.endpointId !== senderClientIdentity.endpointId) {
+	                Array.from(otherClientState.handlerIdsByContextTypes.keys()).forEach((subscribedContextType) => {
+	                    this.provider.dispatch(senderClientIdentity, handlerId, subscribedContextType);
+	                });
+	            }
+	        });
+	    }
+	    onDisconnectHandlerAdded(payload, id) {
+	        const clientState = this.getClientState(id);
+	        const { handlerId } = payload;
+	        if (!clientState) {
+	            throw new Error(`Client with Identity: ${id.uuid} ${id.name}, tried to call onDisconnect, is not connected to this Private Channel`);
+	        }
+	        clientState.onDisconnectHandlerId = handlerId;
+	    }
+	    onUnsubscribeHandlerAdded(payload, id) {
+	        const clientState = this.getClientState(id);
+	        const { handlerId } = payload;
+	        if (!clientState) {
+	            throw new Error(`Client with Identity: ${id.uuid} ${id.name}, tried to call onUnsubscribe, is not connected to this Private Channel`);
+	        }
+	        clientState.onUnsubscribeHandlerId = handlerId;
+	    }
+	    removeClient(disconnectingClientIdentity) {
+	        const disconnectingClientState = this.getClientState(disconnectingClientIdentity);
+	        if (!disconnectingClientState) {
+	            throw new Error(`Client with Identity: ${disconnectingClientIdentity.uuid} ${disconnectingClientIdentity.name}, tried to call disconnect, is not connected to this Private Channel`);
+	        }
+	        disconnectingClientState.handlerIdsByContextTypes.clear();
+	        this.clients.delete(disconnectingClientIdentity.endpointId);
+	    }
+	    async fireOnDisconnectForOtherClients(disconnectingClientIdentity) {
+	        // TODO: call onDisconnect Handler of the other client only.
+	        // CURRENTLY, just calling the onDisconnect handler for all the other clients. Once we limit it to just one other client, we can eliminate all the iteration code.
+	        const { endpointId } = disconnectingClientIdentity;
+	        // getting only valid client connections here, it is possible we haven't removed a disconnected client from the map yet
+	        // so we need to ensure we don't dispatch to any disconnected client
+	        // TODO: Take a look at our client disconnection logic and see if we can handle client disconnection cleanly
+	        const clientsToDispatchTo = await this.getConnectedClients();
+	        const dispatchPromises = clientsToDispatchTo.map(async (otherClientState) => {
+	            const { clientIdentity: { endpointId: otherClientEndpointId }, onDisconnectHandlerId } = otherClientState;
+	            if (otherClientEndpointId !== endpointId && onDisconnectHandlerId) {
+	                await this.provider.dispatch(otherClientState.clientIdentity, onDisconnectHandlerId);
+	            }
+	        });
+	        try {
+	            await Promise.all(dispatchPromises);
+	        }
+	        catch (error) {
+	            console.error(`Problem when attempting to dispatch to onDisconnectHandlers. Error: ${error} Disconnecting Client: uuid: ${disconnectingClientIdentity.uuid}. name: ${disconnectingClientIdentity.name}. endpointId: ${disconnectingClientIdentity.endpointId}`);
+	            throw new Error(error);
+	        }
+	    }
+	    async unsubscribeAll(clientIdentity) {
+	        const { endpointId } = clientIdentity;
+	        const state = this.clients.get(endpointId);
+	        if (state) {
+	            const contextTypeHandlerIds = Array.from(state.handlerIdsByContextTypes.values()).flat();
+	            const globalHandlerId = state.globalHandler;
+	            if (contextTypeHandlerIds.length > 0) {
+	                const unsubPromises = contextTypeHandlerIds.map(async (handlerId) => {
+	                    return this.contextHandlerRemoved({ handlerId }, clientIdentity);
+	                });
+	                try {
+	                    await Promise.all(unsubPromises);
+	                }
+	                catch (error) {
+	                    console.error(error.message);
+	                }
+	            }
+	            if (globalHandlerId) {
+	                try {
+	                    await this.contextHandlerRemoved({ handlerId: globalHandlerId }, clientIdentity);
+	                }
+	                catch (error) {
+	                    console.error(error.message);
+	                }
+	            }
+	        }
+	    }
+	    async handleClientDisconnecting(disconnectingClientIdentity) {
+	        await this.unsubscribeAll(disconnectingClientIdentity);
+	        this.removeClient(disconnectingClientIdentity);
+	        await this.fireOnDisconnectForOtherClients(disconnectingClientIdentity);
+	    }
+	    registerNewClient(clientIdentity) {
+	        if (!this.clients.has(clientIdentity.endpointId)) {
+	            const clientSubscriptionState = {
+	                clientIdentity,
+	                handlerIdsByContextTypes: new Map(),
+	                globalHandler: undefined,
+	                onAddContextListenerHandlerId: undefined,
+	                onUnsubscribeHandlerId: undefined,
+	                onDisconnectHandlerId: undefined
+	            };
+	            this.clients.set(clientIdentity.endpointId, clientSubscriptionState);
+	        }
+	    }
+	    async getConnectedClients() {
+	        const allClientInfo = await this.provider.getAllClientInfo();
+	        return Array.from(this.clients.values()).filter((clientState) => {
+	            const { uuid, name } = clientState.clientIdentity;
+	            return allClientInfo.some((clientInfo) => {
+	                return name === clientInfo.name && uuid === clientInfo.uuid;
+	            });
+	        });
+	    }
+	    static init(channelProvider, id) {
+	        return new PrivateChannelProvider(channelProvider, id);
+	    }
+	};
+	PrivateChannelProvider.PrivateChannelProvider = PrivateChannelProvider$1;
+	return PrivateChannelProvider;
+}
+
+var hasRequiredInteropBroker;
+
+function requireInteropBroker () {
+	if (hasRequiredInteropBroker) return InteropBroker;
+	hasRequiredInteropBroker = 1;
+	var __classPrivateFieldSet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+	    if (kind === "m") throw new TypeError("Private method is not writable");
+	    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+	    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+	    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+	};
+	var __classPrivateFieldGet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+	    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+	    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+	    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+	};
+	var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+	    return (mod && mod.__esModule) ? mod : { "default": mod };
+	};
+	var _InteropBroker_fdc3Info, _InteropBroker_contextGroups, _InteropBroker_providerPromise;
+	Object.defineProperty(InteropBroker, "__esModule", { value: true });
+	InteropBroker.InteropBroker = void 0;
+	const base_1 = base;
+	const SessionContextGroupBroker_1 = __importDefault(requireSessionContextGroupBroker());
+	const utils_1 = utils$3;
+	const isEqual_1 = __importDefault(require$$3);
+	const PrivateChannelProvider_1 = requirePrivateChannelProvider();
+	const lazy_1 = lazy;
+	const defaultContextGroups = [
+	    {
+	        id: 'green',
+	        displayMetadata: {
+	            color: '#00CC88',
+	            name: 'green'
+	        }
+	    },
+	    {
+	        id: 'purple',
+	        displayMetadata: {
+	            color: '#8C61FF',
+	            name: 'purple'
+	        }
+	    },
+	    {
+	        id: 'orange',
+	        displayMetadata: {
+	            color: '#FF8C4C',
+	            name: 'orange'
+	        }
+	    },
+	    {
+	        id: 'red',
+	        displayMetadata: {
+	            color: '#FF5E60',
+	            name: 'red'
+	        }
+	    },
+	    {
+	        id: 'pink',
+	        displayMetadata: {
+	            color: '#FF8FB8',
+	            name: 'pink'
+	        }
+	    },
+	    {
+	        id: 'yellow',
+	        displayMetadata: {
+	            color: '#E9FF8F',
+	            name: 'yellow'
+	        }
+	    }
+	];
+	/**
+	 * {@link https://developers.openfin.co/of-docs/docs/enable-color-linking}
+	 *
+	 * The Interop Broker is responsible for keeping track of the Interop state of the Platform, and for directing messages to the proper locations.
+	 *
+	 * @remarks This class contains some types related to FDC3 that are specific to OpenFin. {@link https://developers.openfin.co/of-docs/docs/fdc3-support-in-openfin OpenFin's FDC3 support} is forward- and backward-compatible.
+	 * Standard types for {@link https://fdc3.finos.org/ FDC3} do not appear in OpenFin’s API documentation, to avoid duplication.
+	 *
+	 * ---
+	 *
+	 * There are 2 ways to inject custom functionality into the Interop Broker:
+	 *
+	 * **1. Configuration**
+	 *
+	 * At the moment, you can configure the default context groups for the Interop Broker without having to override it. To do so, include the `interopBrokerConfiguration` `contextGroups` option in your `platform` options in your manifest. This is the preferred method.
+	 * ```js
+	 * {
+	 *      "runtime": {
+	 *          "arguments": "--v=1 --inspect",
+	 *          "version": "alpha-v19"
+	 *      },
+	 *      "platform": {
+	 *          "uuid": "platform_customization_local",
+	 *          "applicationIcon": "https://openfin.github.io/golden-prototype/favicon.ico",
+	 *          "autoShow": false,
+	 *          "providerUrl": "http://localhost:5555/provider.html",
+	 *          "interopBrokerConfiguration": {
+	 *              "contextGroups": [
+	 *                  {
+	 *                      "id": "green",
+	 *                      "displayMetadata": {
+	 *                          "color": "#00CC88",
+	 *                          "name": "green"
+	 *                      }
+	 *                  },
+	 *                  {
+	 *                      "id": "purple",
+	 *                      "displayMetadata": {
+	 *                          "color": "#8C61FF",
+	 *                          "name": "purple"
+	 *                      }
+	 *                  },
+	 *              ]
+	 *          }
+	 *      }
+	 * }
+	 * ```
+	 *
+	 * By default the Interop Broker logs all actions to the console. You can disable this by using the logging option in `interopBrokerConfiguration`:
+	 * ```js
+	 * {
+	 *      "runtime": {
+	 *          "arguments": "--v=1 --inspect",
+	 *          "version": "alpha-v19"
+	 *      },
+	 *      "platform": {
+	 *          "uuid": "platform_customization_local",
+	 *          "applicationIcon": "https://openfin.github.io/golden-prototype/favicon.ico",
+	 *          "autoShow": false,
+	 *          "providerUrl": "http://localhost:5555/provider.html",
+	 *		    "interopBrokerConfiguration": {
+	 *       		"logging": {
+	 *   				"beforeAction": {
+	 *   					"enabled": false
+	 *   				},
+	 *   				"afterAction": {
+	 *   					"enabled": false
+	 *   				}
+	 *   			}
+	 *		    }
+	 *      }
+	 * }
+	 * ```
+	 *
+	 * ---
+	 * **2. Overriding**
+	 *
+	 * Similarly to how {@link https://developers.openfin.co/docs/platform-customization#section-customizing-platform-behavior Platform Overriding} works, you can override functions in the Interop Broker in `fin.Platform.init`. An example of that is shown below. Overriding `isConnectionAuthorized` and `isActionAuthorized` will allow you to control allowed connections and allowed actions.
+	 *
+	 * However, if there is custom functionality you wish to include in the Interop Broker, please let us know. We would like to provide better configuration options so that you don't have to continually maintain your own override code.
+	 *
+	 * ```js
+	 * fin.Platform.init({
+	 *     overrideCallback: async (Provider) => {
+	 *         class Override extends Provider {
+	 *             async getSnapshot() {
+	 *                 console.log('before getSnapshot')
+	 *                 const snapshot = await super.getSnapshot();
+	 *                 console.log('after getSnapshot')
+	 *                 return snapshot;
+	 *             }
+	 *
+	 *             async applySnapshot({ snapshot, options }) {
+	 *                 console.log('before applySnapshot')
+	 *                 const originalPromise = super.applySnapshot({ snapshot, options });
+	 *                 console.log('after applySnapshot')
+	 *
+	 *                 return originalPromise;
+	 *             }
+	 *         };
+	 *         return new Override();
+	 *     },
+	 *     interopOverride: async (InteropBroker) => {
+	 *         class Override extends InteropBroker {
+	 *             async joinContextGroup(channelName = 'default', target) {
+	 *                 console.log('before super joinContextGroup')
+	 *                 super.joinContextGroup(channelName, target);
+	 *                 console.log('after super joinContextGroup')
+	 *             }
+	 *         }
+	 *
+	 *       return new Override();
+	 *   }
+	 * });
+	 * ```
+	 *
+	 * ---
+	 *
+	 */
+	let InteropBroker$1 = class InteropBroker extends base_1.Base {
+	    /**
+	     * @internal
+	     */
+	    constructor(wire, createProvider, options) {
+	        // Tip from Pierre and Michael from the overrideCheck work: Don't use bound methods for overrideable InteropBroker functions.
+	        super(wire);
+	        _InteropBroker_fdc3Info.set(this, void 0);
+	        _InteropBroker_contextGroups.set(this, void 0);
+	        _InteropBroker_providerPromise.set(this, void 0);
+	        this.getProvider = () => {
+	            return __classPrivateFieldGet(this, _InteropBroker_providerPromise, "f").getValue();
+	        };
+	        this.interopClients = new Map();
+	        this.contextGroupsById = new Map();
+	        __classPrivateFieldSet(this, _InteropBroker_contextGroups, options.contextGroups ?? [...defaultContextGroups], "f");
+	        __classPrivateFieldSet(this, _InteropBroker_fdc3Info, options.fdc3Info, "f");
+	        if (options?.logging) {
+	            this.logging = options.logging;
+	        }
+	        this.intentClientMap = new Map();
+	        this.lastContextMap = new Map();
+	        this.sessionContextGroupMap = new Map();
+	        __classPrivateFieldSet(this, _InteropBroker_providerPromise, new lazy_1.Lazy(createProvider), "f");
+	        this.setContextGroupMap();
+	        this.setupChannelProvider();
+	    }
+	    static createClosedConstructor(...args) {
+	        return class OverrideableBroker extends InteropBroker {
+	            constructor(...unused) {
+	                if (unused.length) {
+	                    const [_ignore1, ignore2, opts] = unused;
+	                    if (opts && typeof opts === 'object' && !(0, isEqual_1.default)(opts, args[2])) {
+	                        // eslint-disable-next-line no-console
+	                        console.warn('You have modified the parameters of the InteropOverride constructor. This behavior is deprecated and will be removed in a future version. You can modify these options in your manifest. Please consult our Interop docs for guidance on migrating to the new override scheme.');
+	                        super(args[0], args[1], opts);
+	                        return;
+	                    }
+	                    // eslint-disable-next-line no-console
+	                    console.warn('You are attempting to pass arguments to the InteropOverride constructor. This is not necessary, and these passed arguments will be ignored. You are likely using an older InteropBroker override scheme. Please consult our Interop docs for guidance on migrating to the new override scheme.');
+	                }
+	                super(...args);
+	            }
+	        };
+	    }
+	    /*
+	    Client API
+	    */
+	    /**
+	     * Sets a context for the context group of the incoming current entity.
+	     * @param setContextOptions - New context to set.
+	     * @param clientIdentity - Identity of the client sender.
+	     *
+	     */
+	    setContext({ context }, clientIdentity) {
+	        this.wire.sendAction('interop-broker-set-context').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        const clientState = this.getClientState(clientIdentity);
+	        if (clientState && clientState.contextGroupId) {
+	            const { contextGroupId } = clientState;
+	            this.setContextForGroup({ context }, contextGroupId);
+	        }
+	        else if (clientState) {
+	            // Client has not joined any context group behavior.
+	            throw new Error('You must join a context group before you can set context.');
+	        }
+	        else {
+	            // This shouldn't get hit.
+	            throw new Error(`Client with Identity: ${clientIdentity.uuid} ${clientIdentity.name} not in Client State Map`);
+	        }
+	    }
+	    /**
+	     * Sets a context for the context group.
+	     * @param setContextOptions - New context to set.
+	     * @param contextGroupId - Context group id.
+	     *
+	     */
+	    setContextForGroup({ context }, contextGroupId) {
+	        this.wire.sendAction('interop-broker-set-context-for-group').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        const contextGroupState = this.contextGroupsById.get(contextGroupId);
+	        if (!contextGroupState) {
+	            throw new Error(`Unable to set context for context group that isn't in the context group mapping: ${contextGroupId}.`);
+	        }
+	        const contextIntegrityCheckResult = InteropBroker.checkContextIntegrity(context);
+	        if (contextIntegrityCheckResult.isValid === false) {
+	            throw new Error(`Failed to set Context - bad Context. Reason: ${contextIntegrityCheckResult.reason}. Context: ${JSON.stringify(context)}`);
+	        }
+	        const broadcastedContextType = context.type;
+	        contextGroupState.set(broadcastedContextType, context);
+	        this.lastContextMap.set(contextGroupId, broadcastedContextType);
+	        const clientsInSameContextGroup = Array.from(this.interopClients.values()).filter((connectedClient) => connectedClient.contextGroupId === contextGroupId);
+	        clientsInSameContextGroup.forEach((client) => {
+	            for (const [, handlerInfo] of client.contextHandlers) {
+	                if (InteropBroker.isContextTypeCompatible(broadcastedContextType, handlerInfo.contextType)) {
+	                    this.invokeContextHandler(client.clientIdentity, handlerInfo.handlerId, context);
+	                }
+	            }
+	        });
+	    }
+	    /**
+	     * Get current context for a client subscribed to a Context Group.
+	     *
+	     * @remarks It takes an optional Context Type argument and returns the last context of that type.
+	     *
+	     * @param getContextOptions - Options for getting context
+	     * @param clientIdentity - Identity of the client sender.
+	     *
+	     */
+	    getCurrentContext(getCurrentContextOptions, clientIdentity) {
+	        this.wire.sendAction('interop-broker-get-current-context').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        const clientState = this.getClientState(clientIdentity);
+	        if (!clientState?.contextGroupId) {
+	            throw new Error('You must be a member of a context group to call getCurrentContext');
+	        }
+	        const { contextGroupId } = clientState;
+	        const contextGroupState = this.contextGroupsById.get(contextGroupId);
+	        const lastContextType = this.lastContextMap.get(contextGroupId);
+	        const contextType = getCurrentContextOptions?.contextType ?? lastContextType;
+	        return contextGroupState && contextType ? contextGroupState.get(contextType) : undefined;
+	    }
+	    /*
+	    Platform Window APIs
+	    */
+	    // joinContextGroup and addClientToContextGroup are separate functions here, for easier overrides and separation of concerns.
+	    // joinContextGroup checks all connections for matching identities, in case we have multiple connection from an entity.
+	    /**
+	     * Join all connections at the given identity (or just one if endpointId provided) to context group `contextGroupId`.
+	     * If no target is specified, it adds the sender to the context group.
+	     * joinContextGroup is responsible for checking connections at the incoming identity. It calls {@link InteropBroker#addClientToContextGroup InteropBroker.addClientToContextGroup} to actually group the client.
+	     * Used by Platform Windows.
+	     *
+	     * @param joinContextGroupOptions - Id of the Context Group and identity of the entity to join to the group.
+	     * @param senderIdentity - Identity of the client sender.
+	     */
+	    async joinContextGroup({ contextGroupId, target }, senderIdentity) {
+	        this.wire.sendAction('interop-broker-join-context-group').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        if (this.sessionContextGroupMap.has(contextGroupId)) {
+	            throw new Error(utils_1.BROKER_ERRORS.joinSessionContextGroupWithJoinContextGroup);
+	        }
+	        if (target) {
+	            // If an endpointId is provided, use that. This will likely be used by external adapters.
+	            if (InteropBroker.hasEndpointId(target)) {
+	                await this.addClientToContextGroup({ contextGroupId }, target);
+	            }
+	            // Sanity check here in case a single app has multiple connections
+	            try {
+	                const allConnections = this.channel.connections.filter((x) => x.uuid === target.uuid && x.name === target.name);
+	                if (!allConnections.length) {
+	                    throw new Error(`Given Identity ${target.uuid} ${target.name} is not connected to the Interop Broker.`);
+	                }
+	                if (allConnections.length > 1) {
+	                    // Should figure out how we want to handle this situation. In the meantime, just change context group for all connections.
+	                    console.warn(`More than one connection found for identity ${target.uuid} ${target.name}`);
+	                }
+	                const promises = [];
+	                for (const connection of allConnections) {
+	                    promises.push(this.addClientToContextGroup({ contextGroupId }, connection));
+	                }
+	                await Promise.all(promises);
+	            }
+	            catch (error) {
+	                throw new Error(error);
+	            }
+	        }
+	        else {
+	            // No target provided, add the sender to the context group.
+	            await this.addClientToContextGroup({ contextGroupId }, senderIdentity);
+	        }
+	    }
+	    // addClientToContextGroup does the actual addition of the client to the Context Group
+	    /**
+	     * Helper function for {@link InteropBroker#joinContextGroup InteropBroker.joinContextGroup}. Does the work of actually adding the client to the Context Group.
+	     * Used by Platform Windows.
+	     *
+	     * @param addClientToContextGroupOptions - Contains the contextGroupId
+	     * @param clientIdentity - Identity of the client sender.
+	     */
+	    async addClientToContextGroup({ contextGroupId }, clientIdentity) {
+	        this.wire.sendAction('interop-broker-add-client-to-context-group').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        const clientSubscriptionState = this.getClientState(clientIdentity);
+	        if (!clientSubscriptionState) {
+	            throw new Error(`Client with Identity: ${clientIdentity.uuid} ${clientIdentity.name} not in Client State Map`);
+	        }
+	        if (!this.getContextGroups().find((contextGroupInfo) => contextGroupInfo.id === contextGroupId)) {
+	            throw new Error(`Attempting to join a context group that does not exist: ${contextGroupId}. You may only join existing context groups.`);
+	        }
+	        const oldContextGroupId = clientSubscriptionState.contextGroupId;
+	        if (oldContextGroupId !== contextGroupId) {
+	            clientSubscriptionState.contextGroupId = contextGroupId;
+	            await this.setCurrentContextGroupInClientOptions(clientIdentity, contextGroupId);
+	            const contextGroupMap = this.contextGroupsById.get(contextGroupId);
+	            for (const [, handlerInfo] of clientSubscriptionState.contextHandlers) {
+	                const { contextType, handlerId } = handlerInfo;
+	                if (contextType === undefined) {
+	                    // Send this single handler all of the context, because it accepts all.
+	                    contextGroupMap.forEach((context, _) => {
+	                        this.invokeContextHandler(clientIdentity, handlerId, context);
+	                    });
+	                }
+	                else if (contextGroupMap.has(contextType)) {
+	                    const contextForType = contextGroupMap.get(contextType);
+	                    if (contextForType) {
+	                        this.invokeContextHandler(clientIdentity, handlerId, contextForType);
+	                    }
+	                }
+	            }
+	        }
+	    }
+	    // Removes the target from its context group. Similar structure to joinContextGroup.
+	    /**
+	     * Removes the specified target from a context group.
+	     * If no target is specified, it removes the sender from their context group.
+	     * removeFromContextGroup is responsible for checking connections at the incoming identity.
+	     *
+	     * @remarks It calls {@link InteropBroker#removeClientFromContextGroup InteropBroker.removeClientFromContextGroup} to actually ungroup
+	     * the client. Used by Platform Windows.
+	     *
+	     * @param removeFromContextGroupOptions - Contains the target identity to remove.
+	     * @param senderIdentity - Identity of the client sender.
+	     */
+	    async removeFromContextGroup({ target }, senderIdentity) {
+	        this.wire.sendAction('interop-broker-remove-from-context-group').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        if (target) {
+	            // If an endpointId is provided, use that. This will likely be used by external adapters.
+	            if (InteropBroker.hasEndpointId(target)) {
+	                await this.removeClientFromContextGroup(target);
+	            }
+	            try {
+	                // Sanity check here in case a single app has multiple connections
+	                const allConnections = this.channel.connections.filter((x) => x.uuid === target.uuid && x.name === target.name);
+	                if (!allConnections.length) {
+	                    throw new Error(`No connection found for given Identity ${target.uuid} ${target.name}`);
+	                }
+	                if (allConnections.length > 1) {
+	                    console.warn(`More than one connection found for identity ${target.uuid} ${target.name}`);
+	                }
+	                const promises = [];
+	                for (const connection of allConnections) {
+	                    promises.push(this.removeClientFromContextGroup(connection));
+	                }
+	                await Promise.all(promises);
+	            }
+	            catch (error) {
+	                throw new Error(error);
+	            }
+	        }
+	        else {
+	            // No target provided, remove the sender from the context group.
+	            await this.removeClientFromContextGroup(senderIdentity);
+	        }
+	    }
+	    // removeClientFromContextGroup does the actual remove of the client from the Context Group
+	    /**
+	     * Helper function for {@link InteropBroker#removeFromContextGroup InteropBroker.removeFromContextGroup}. Does the work of actually removing the client from the Context Group.
+	     * Used by Platform Windows.
+	     *
+	     * @property { ClientIdentity } clientIdentity - Identity of the client sender.
+	     */
+	    async removeClientFromContextGroup(clientIdentity) {
+	        this.wire.sendAction('interop-broker-remove-client-from-context-group').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        const clientState = this.getClientState(clientIdentity);
+	        if (clientState) {
+	            clientState.contextGroupId = undefined;
+	        }
+	        await this.setCurrentContextGroupInClientOptions(clientIdentity, null);
+	    }
+	    // Used by platform windows to know what client groups the provider has declared. Also used internally to access context groups. Overrideable so that the platform developer can modify it.
+	    /**
+	     * Returns the Interop-Broker-defined context groups available for an entity to join. Because this function is used in the rest of the Interop Broker to fetch the Context Groups, overriding this allows you to customize the Context Groups for the Interop Broker. However, we recommend customizing the context groups through configuration instead.
+	     * Used by Platform Windows.
+	     *
+	     */
+	    // eslint-disable-next-line class-methods-use-this
+	    getContextGroups() {
+	        this.wire.sendAction('interop-broker-get-context-groups').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        // Create copy for immutability
+	        return __classPrivateFieldGet(this, _InteropBroker_contextGroups, "f").map((contextGroup) => {
+	            return { ...contextGroup };
+	        });
+	    }
+	    // Used to by platform windows to get display metadata for a context group.
+	    /**
+	     * Gets display info for a context group
+	     *
+	     * @remarks Used by Platform Windows.
+	     *
+	     * @param getInfoForContextGroupOptions - Contains contextGroupId, the context group you wish to get display info for.
+	     *
+	     */
+	    getInfoForContextGroup({ contextGroupId }) {
+	        this.wire.sendAction('interop-broker-get-info-for-context-group').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        return this.getContextGroups().find((contextGroup) => contextGroup.id === contextGroupId);
+	    }
+	    // Used by platform windows to get all clients for a context group.
+	    /**
+	     * Gets all clients for a context group.
+	     *
+	     * @remarks **This is primarily used for platform windows. Views within a platform should not have to use this API.**
+	     * Returns the Interop-Broker-defined context groups available for an entity to join.
+	     *
+	     * @param getAllClientsInContextGroupOptions - Contains contextGroupId, the context group you wish to get clients for.
+	     *
+	     */
+	    getAllClientsInContextGroup({ contextGroupId }) {
+	        this.wire.sendAction('interop-broker-get-all-clients-in-context-group').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        const clientsInContextGroup = Array.from(this.interopClients.values())
+	            .filter((connectedClient) => connectedClient.contextGroupId === contextGroupId)
+	            .map((subscriptionState) => {
+	            return subscriptionState.clientIdentity;
+	        });
+	        return clientsInContextGroup;
+	    }
+	    /**
+	     * Responsible for launching of applications that can handle a given intent, and delegation of intents to those applications.
+	     * Must be overridden.
+	     *
+	     * @remarks To make this call FDC3-Compliant it would need to return an IntentResolution.
+	     *
+	     * ```js
+	     * interface IntentResolution {
+	     *   source: TargetApp;
+	     *   // deprecated, not assignable from intent listeners
+	     *   data?: object;
+	     *   version: string;
+	     * }
+	     * ```
+	     *
+	     * More information on the IntentResolution type can be found in the [FDC3 documentation](https://fdc3.finos.org/docs/api/ref/IntentResolution).
+	     *
+	     * @param intent The combination of an action and a context that is passed to an application for resolution.
+	     * @param  clientIdentity Identity of the Client making the request.
+	     *
+	     * @example
+	     * ```js
+	     * // override call so we set intent target and create view that will handle it
+	     * fin.Platform.init({
+	     *     interopOverride: async (InteropBroker) => {
+	     *         class Override extends InteropBroker {
+	     *             async handleFiredIntent(intent) {
+	     *                 super.setIntentTarget(intent, { uuid: 'platform-uuid', name: 'intent-view' });
+	     *                 const platform = fin.Platform.getCurrentSync();
+	     *                 const win = fin.Window.wrapSync({ name: 'foo', uuid: 'platform-uuid' });
+	     *                 const createdView = await platform.createView({ url: 'http://openfin.co', name: 'intent-view' }, win.identity);
+	     *             }
+	     *         }
+	     *         return new Override();
+	     *     }
+	     * });
+	     * ```
+	     */
+	    // eslint-disable-next-line class-methods-use-this
+	    async handleFiredIntent(intent, clientIdentity // TODO(CORE-811): remove inline intersected type
+	    ) {
+	        const warning = (0, utils_1.generateOverrideWarning)('fdc3.raiseIntent', 'InteropBroker.handleFiredIntent', clientIdentity, 'interopClient.fireIntent');
+	        console.warn(warning);
+	        throw new Error(utils_1.BROKER_ERRORS.fireIntent);
+	    }
+	    /**
+	     * Should be called in {@link InteropBroker#handleFiredIntent InteropBroker.handleFiredIntent}.
+	     * While handleFiredIntent is responsible for launching applications, setIntentTarget is used to tell the InteropBroker which application should receive the intent when it is ready.
+	     * @param intent The combination of an action and a context that is passed to an application for resolution.
+	     * @param target - Identity of the target that will handle the intent.
+	     *
+	     */
+	    async setIntentTarget(intent, target) {
+	        this.wire.sendAction('interop-broker-set-intent-target').catch((e) => {
+	            // don't expose, this is only for api analytics purposes
+	        });
+	        const targetInfo = this.intentClientMap.get(target.name);
+	        const handlerId = `intent-handler-${intent.name}`;
+	        if (!targetInfo) {
+	            this.intentClientMap.set(target.name, new Map());
+	            const newHandlerInfoMap = this.intentClientMap.get(target.name);
+	            if (newHandlerInfoMap) {
+	                newHandlerInfoMap.set(handlerId, { isReady: false, pendingIntents: [intent] });
+	            }
+	        }
+	        else {
+	            const handlerInfo = targetInfo.get(handlerId);
+	            if (!handlerInfo) {
+	                targetInfo.set(handlerId, { isReady: false, pendingIntents: [intent] });
+	            }
+	            else {
+	                handlerInfo.pendingIntents.push(intent);
+	                if (handlerInfo.clientIdentity && handlerInfo.isReady) {
+	                    const { clientIdentity, pendingIntents } = handlerInfo;
+	                    try {
+	                        const intentToSend = pendingIntents[pendingIntents.length - 1];
+	                        await this.invokeIntentHandler(clientIdentity, handlerId, intentToSend);
+	                        handlerInfo.pendingIntents = [];
+	                    }
+	                    catch (error) {
+	                        console.error(`Error invoking intent handler for client ${clientIdentity.uuid}/${clientIdentity.name}/${clientIdentity.endpointId}`);
+	                        handlerInfo.isReady = false;
+	                    }
+	                }
+	            }
+	        }
+	    }
+	    /**
+	     * Responsible for returning information on a particular Intent.
+	     *
+	     * @remarks Whenever InteropClient.getInfoForIntent is called this function will fire. The options argument gives you
+	     * access to the intent name and any optional context that was passed and clientIdentity is the identity of the client
+	     * that made the call. Ideally here you would fetch the info for the intent and return it with the shape that the
+	     * InteropClient.getInfoForIntent call is expecting.
+	     *
+	     * To make this call FDC3-Compliant it would need to return an App Intent:
+	     *
+	     * ```js
+	     * // {
+	     * //     intent: { name: "StartChat", displayName: "Chat" },
+	     * //     apps: [{ name: "Skype" }, { name: "Symphony" }, { name: "Slack" }]
+	     * // }
+	     * ```
+	     *
+	     * More information on the AppIntent type can be found in the [FDC3 documentation](https://fdc3.finos.org/docs/api/ref/AppIntent).
+	     *
+	     * @param options
+	     * @param clientIdentity Identity of the Client making the request.
+	     *
+	     * @example
+	     * ```js
+	     * fin.Platform.init({
+	     *     interopOverride: async (InteropBroker) => {
+	     *         class Override extends InteropBroker {
+	     *             async handleInfoForIntent(options, clientIdentity) {
+	     *                 // Your code goes here.
+	     *             }
+	     *         }
+	     *         return new Override();
+	     *     }
+	     * });
+	     * ```
+	     */
+	    // eslint-disable-next-line class-methods-use-this
+	    async handleInfoForIntent(options, clientIdentity // TODO(CORE-811): remove inline intersected type
+	    ) {
+	        const warning = (0, utils_1.generateOverrideWarning)('fdc3.findIntent', 'InteropBroker.handleInfoForIntent', clientIdentity, 'interopClient.getInfoForIntent');
+	        console.warn(warning);
+	        throw new Error(utils_1.BROKER_ERRORS.getInfoForIntent);
+	    }
+	    /**
+	     * Responsible for returning information on which Intents are meant to handle a specific Context.
+	     * Must be overridden.
+	     *
+	     * @remarks Responsible for returning information on which Intents are meant to handle a specific Context. Must be overridden.
+	     *
+	     * Whenever InteropClient.getInfoForIntentsByContext is called this function will fire. The context argument gives you access to the context that the client wants information on and clientIdentity is the identity of the client that made the call. Ideally here you would fetch the info for any intent that can handle and return it with the shape that the InteropClient.getInfoForIntentsByContext call is expecting.
+	     *
+	     * To make this call FDC3-Compliant it would need to return an array of AppIntents:
+	     *
+	     * ```js
+	     * // [{
+	     * //     intent: { name: "StartCall", displayName: "Call" },
+	     * //     apps: [{ name: "Skype" }]
+	     * // },
+	     * // {
+	     * //     intent: { name: "StartChat", displayName: "Chat" },
+	     * //     apps: [{ name: "Skype" }, { name: "Symphony" }, { name: "Slack" }]
+	     * // }];
+	     * ```
+	     *
+	     * More information on the AppIntent type can be found in the [FDC3 documentation](https://fdc3.finos.org/docs/api/ref/AppIntent).
+	     *
+	     * @param context Data passed between entities and applications.
+	     * @param clientIdentity Identity of the Client making the request.
+	     *
+	     * @example
+	     * ```js
+	     * fin.Platform.init({
+	     *     interopOverride: async (InteropBroker) => {
+	     *         class Override extends InteropBroker {
+	     *             async handleInfoForIntentsByContext(context, clientIdentity) {
+	     *                 // Your code goes here.
+	     *             }
+	     *         }
+	     *         return new Override();
+	     *     }
+	     * });
+	     * ```
+	     */
+	    // eslint-disable-next-line class-methods-use-this
+	    async handleInfoForIntentsByContext(context, clientIdentity // TODO(CORE-811): remove inline intersected type
+	    ) {
+	        const warning = (0, utils_1.generateOverrideWarning)('fdc3.findIntentsByContext', 'InteropBroker.handleInfoForIntentsByContext', clientIdentity, 'interopClient.getInfoForIntentsByContext');
+	        console.warn(warning);
+	        throw new Error(utils_1.BROKER_ERRORS.getInfoForIntentsByContext);
+	    }
+	    /**
+	     * Responsible for resolving an Intent based on a specific Context.
+	     * Must be overridden.
+	     *
+	     * @remarks Whenever InteropClient.fireIntentForContext is called this function will fire. The contextForIntent argument
+	     * gives you access to the context that will be resolved to an intent. It also can optionally contain any metadata relevant
+	     * to resolving it, like a specific app the client wants the context to be handled by. The clientIdentity is the identity
+	     * of the client that made the call.
+	     *
+	     * To make this call FDC3-Compliant it would need to return an IntentResolution:
+	     *
+	     * ```js
+	     * // {
+	     * //     intent: { name: "StartChat", displayName: "Chat" },
+	     * //     apps: [{ name: "Skype" }, { name: "Symphony" }, { name: "Slack" }]
+	     * // }
+	     * ```
+	     *
+	     * More information on the IntentResolution type can be found in the [FDC3 documentation](https://fdc3.finos.org/docs/api/ref/Metadata#intentresolution).
+	     *
+	     * @param contextForIntent Data passed between entities and applications.
+	     * @param clientIdentity Identity of the Client making the request.
+	     *
+	     * @example
+	     * ```js
+	     * fin.Platform.init({
+	     *     interopOverride: async (InteropBroker) => {
+	     *         class Override extends InteropBroker {
+	     *             async handleFiredIntentForContext(contextForIntent, clientIdentity) {
+	     *                 // Your code goes here.
+	     *             }
+	     *         }
+	     *         return new Override();
+	     *     }
+	     * });
+	     * ```
+	     */
+	    // eslint-disable-next-line class-methods-use-this
+	    async handleFiredIntentForContext(contextForIntent, clientIdentity) {
+	        const warning = (0, utils_1.generateOverrideWarning)('fdc3.raiseIntentForContext', 'InteropBroker.handleFiredIntentForContext', clientIdentity, 'interopClient.fireIntentForContext');
+	        console.warn(warning);
+	        throw new Error(utils_1.BROKER_ERRORS.fireIntentForContext);
+	    }
+	    /**
+	     * Provides the identity of any Interop Client that disconnects from the Interop Broker. It is meant to be overriden.
+	     * @param clientIdentity
+	     *
+	     * @example
+	     * ```js
+	     * fin.Platform.init({
+	     *     interopOverride: async (InteropBroker) => {
+	     *         class Override extends InteropBroker {
+	     *             async clientDisconnected(clientIdentity) {
+	     *                 const { uuid, name } = clientIdentity;
+	     *                 console.log(`Client with identity ${uuid}/${name} has been disconnected`);
+	     *             }
+	     *         }
+	     *         return new Override();
+	     *     }
+	     * });
+	     * ```
+	     */
+	    // eslint-disable-next-line class-methods-use-this
+	    async clientDisconnected(clientIdentity) {
+	        // This function is called in channel.onDisconnection.
+	        // It is meant to be overridden to inform when an Interop Client has been disconnected.
+	    }
+	    /**
+	     * Responsible for resolving an fdc3.open call.
+	     * Must be overridden.
+	     * @param fdc3OpenOptions fdc3.open options
+	     * @param clientIdentity Identity of the Client making the request.
+	     */
+	    // eslint-disable-next-line class-methods-use-this
+	    async fdc3HandleOpen({ app, context }, clientIdentity) {
+	        const warning = (0, utils_1.generateOverrideWarning)('fdc3.open', 'InteropBroker.fdc3HandleOpen', clientIdentity);
+	        console.warn(warning);
+	        throw new Error(utils_1.BROKER_ERRORS.fdc3Open);
+	    }
+	    /**
+	     * Responsible for resolving the fdc3.findInstances call.
+	     * Must be overridden
+	     * @param app AppIdentifier that was passed to fdc3.findInstances
+	     * @param clientIdentity Identity of the Client making the request.
+	     */
+	    // eslint-disable-next-line class-methods-use-this
+	    async fdc3HandleFindInstances(app, clientIdentity) {
+	        const warning = (0, utils_1.generateOverrideWarning)('fdc3.open', 'InteropBroker.fdc3HandleFindInstances', clientIdentity);
+	        console.warn(warning);
+	        throw new Error(utils_1.BROKER_ERRORS.fdc3FindInstances);
+	    }
+	    /**
+	     * Responsible for resolving the fdc3.getAppMetadata call.
+	     * Must be overridden
+	     * @param app AppIdentifier that was passed to fdc3.getAppMetadata
+	     * @param clientIdentity Identity of the Client making the request.
+	     */
+	    // eslint-disable-next-line class-methods-use-this
+	    async fdc3HandleGetAppMetadata(app, clientIdentity) {
+	        const warning = (0, utils_1.generateOverrideWarning)('fdc3.getAppMetadata', 'InteropBroker.fdc3HandleGetAppMetadata', clientIdentity);
+	        console.warn(warning);
+	        throw new Error(utils_1.BROKER_ERRORS.fdc3GetAppMetadata);
+	    }
+	    /**
+	     * This function is called by the Interop Broker whenever a Context handler would fire.
+	     * For FDC3 2.0 you would need to override this function and add the contextMetadata as
+	     * part of the Context object. Then would you need to call
+	     * super.invokeContextHandler passing it this new Context object along with the clientIdentity and handlerId
+	     * @param clientIdentity
+	     * @param handlerId
+	     * @param context
+	     *
+	     * @example
+	     * ```js
+	     * fin.Platform.init({
+	     *     interopOverride: async (InteropBroker) => {
+	     *         class Override extends InteropBroker {
+	     *             async invokeContextHandler(clientIdentity, handlerId, context) {
+	     *                 return super.invokeContextHandler(clientIdentity, handlerId, {
+	     *                     ...context,
+	     *                     contextMetadata: {
+	     *                         source: {
+	     *                             appId: 'openfin-app',
+	     *                             instanceId: '3D54D456D9HT0'
+	     *                         }
+	     *                     }
+	     *                 });
+	     *             }
+	     *         }
+	     *         return new Override();
+	     *     }
+	     * });
+	     * ```
+	     */
+	    async invokeContextHandler(clientIdentity, handlerId, context) {
+	        const provider = await this.getProvider();
+	        try {
+	            await provider.dispatch(clientIdentity, handlerId, context);
+	        }
+	        catch (error) {
+	            console.error(`Error invoking context handler ${handlerId} for context type ${context.type} in client ${clientIdentity.uuid}/${clientIdentity.name}/${clientIdentity.endpointId}`, error);
+	        }
+	    }
+	    /**
+	     * This function is called by the Interop Broker whenever an Intent handler would fire.
+	     * For FDC3 2.0 you would need to override this function and add the contextMetadata as
+	     * part of the Context object inside the Intent object. Then would you need to call
+	     * super.invokeIntentHandler passing it this new Intent object along with the clientIdentity and handlerId
+	     * @param ClientIdentity
+	     * @param handlerId
+	     * @param context
+	     *
+	     * @example
+	     * ```js
+	     * fin.Platform.init({
+	     *     interopOverride: async (InteropBroker) => {
+	     *         class Override extends InteropBroker {
+	     *             async invokeIntentHandler(clientIdentity, handlerId, context) {
+	     *                 const { context } = intent;
+	     *                 return super.invokeIntentHandler(clientIdentity, handlerId, {
+	     *                     ...intent,
+	     *                     context: {
+	     *                         ...context,
+	     *                         contextMetadata: {
+	     *                             source: {
+	     *                                 appId: 'openfin-app',
+	     *                                 instanceId: '3D54D456D9HT0'
+	     *                             }
+	     *                         }
+	     *                     }
+	     *                 });
+	     *             }
+	     *         }
+	     *         return new Override();
+	     *     }
+	     * });
+	     * ```
+	     */
+	    async invokeIntentHandler(clientIdentity, handlerId, intent) {
+	        const provider = await this.getProvider();
+	        await provider.dispatch(clientIdentity, handlerId, intent);
+	    }
+	    /**
+	     * Responsible for resolving fdc3.getInfo for FDC3 2.0
+	     * Would need to return the optionalFeatures and appMetadata for the {@link https://fdc3.finos.org/docs/api/ref/Metadata#implementationmetadata ImplementationMetadata}.
+	     * Must be overridden.
+	     * @param clientIdentity
+	     *
+	     */
+	    // eslint-disable-next-line class-methods-use-this
+	    async fdc3HandleGetInfo(payload, clientIdentity) {
+	        const { fdc3Version } = payload;
+	        return {
+	            fdc3Version,
+	            ...__classPrivateFieldGet(this, _InteropBroker_fdc3Info, "f"),
+	            optionalFeatures: {
+	                OriginatingAppMetadata: false,
+	                UserChannelMembershipAPIs: true
+	            },
+	            appMetadata: {
+	                appId: '',
+	                instanceId: ''
+	            }
+	        };
+	    }
+	    /**
+	     * Returns an array of info for each Interop Client connected to the Interop Broker.
+	     *
+	     * FDC3 2.0: Use the endpointId in the ClientInfo as the instanceId when generating
+	     * an AppIdentifier.
+	     *
+	     * @remarks FDC3 2.0 Note: When needing an instanceId to generate an AppIdentifier use this call to
+	     * get the endpointId and use it as the instanceId. In the Example below we override handleFiredIntent
+	     * and then call super.getAllClientInfo to generate the AppIdentifier for the IntentResolution.
+	     *
+	     *
+	     * @example
+	     * ```js
+	     * // FDC3 2.0 Example:
+	     * fin.Platform.init({
+	     *     interopOverride: async (InteropBroker, ...args) => {
+	     *         class Override extends InteropBroker {
+	     *             async handleFiredIntent(intent) {
+	     *                 super.setIntentTarget(intent, { uuid: 'platform-uuid', name: 'intent-view' });
+	     *                 const platform = fin.Platform.getCurrentSync();
+	     *                 const win = fin.Window.wrapSync({ name: 'foo', uuid: 'platform-uuid' });
+	     *                 const createdView = await platform.createView({ url: 'http://openfin.co', name: 'intent-view' }, win.identity);
+	     *
+	     *                 const allClientInfo = await super.getAllClientInfo();
+	     *
+	     *                 const infoForTarget = allClientInfo.find((clientInfo) => {
+	     *                     return clientInfo.uuid === 'platform-uuid' && clientInfo.name === 'intent-view';
+	     *                 });
+	     *
+	     *                 const source = {
+	     *                     appId: 'intent-view',
+	     *                     instanceId: infoForTarget.endpointId
+	     *                 }
+	     *
+	     *                 return {
+	     *                     source,
+	     *                     intent: intent.name
+	     *                 }
+	     *
+	     *             }
+	     *         }
+	     *         return new Override(...args);
+	     *     }
+	     * });
+	     * ```
+	     */
+	    async getAllClientInfo() {
+	        const provider = await this.getProvider();
+	        return provider.getAllClientInfo();
+	    }
+	    /*
+	    Snapshot APIs
+	    */
+	    // Used to save interop broker state in snapshots
+	    decorateSnapshot(snapshot) {
+	        return { ...snapshot, interopSnapshotDetails: { contextGroupStates: this.getContextGroupStates() } };
+	    }
+	    // Used to restore interop broker state in snapshots.
+	    applySnapshot(snapshot, options) {
+	        const contextGroupStates = snapshot?.interopSnapshotDetails?.contextGroupStates;
+	        if (contextGroupStates) {
+	            if (!options?.closeExistingWindows) {
+	                this.updateExistingClients(contextGroupStates);
+	            }
+	            this.rehydrateContextGroupStates(contextGroupStates);
+	        }
+	    }
+	    updateExistingClients(contextGroupStates) {
+	        const clients = this.interopClients;
+	        clients.forEach((subState) => {
+	            const { clientIdentity, contextGroupId, contextHandlers } = subState;
+	            if (contextGroupId) {
+	                const groupContexts = contextGroupStates[contextGroupId];
+	                for (const [, context] of Object.entries(groupContexts)) {
+	                    contextHandlers.forEach((contextHandler) => {
+	                        const { handlerId, contextType } = contextHandler;
+	                        if (InteropBroker.isContextTypeCompatible(context.type, contextType)) {
+	                            this.invokeContextHandler(clientIdentity, handlerId, context);
+	                        }
+	                    });
+	                }
+	            }
+	        });
+	    }
+	    // Used to store context group state in snapshots
+	    getContextGroupStates() {
+	        return InteropBroker.toObject(this.contextGroupsById);
+	    }
+	    // Used to rehydrate the context state from a snapshot
+	    rehydrateContextGroupStates(incomingContextGroupStates) {
+	        const contextGroupStates = Object.entries(incomingContextGroupStates);
+	        for (const [contextGroupId, contexts] of contextGroupStates) {
+	            const contextObjects = Object.entries(contexts);
+	            for (const [contextType, context] of contextObjects) {
+	                if (this.contextGroupsById.has(contextGroupId)) {
+	                    const currentContextGroupState = this.contextGroupsById.get(contextGroupId);
+	                    currentContextGroupState.set(contextType, context);
+	                }
+	                else {
+	                    // This logic will change when dynamic context group creation comes in.
+	                    console.warn(`Attempting to set a context group that isn't in the context group mapping. Skipping context group rehydration for: ${contextGroupId}`);
+	                }
+	            }
+	        }
+	    }
+	    /*
+	    Internal Context Handler APIs
+	    */
+	    // Used to give context to a client that has registered their context handler
+	    contextHandlerRegistered({ contextType, handlerId }, clientIdentity) {
+	        const handlerInfo = { contextType, handlerId };
+	        const clientState = this.getClientState(clientIdentity);
+	        clientState?.contextHandlers.set(handlerId, handlerInfo);
+	        if (clientState && clientState.contextGroupId) {
+	            const { contextGroupId } = clientState;
+	            const contextGroupMap = this.contextGroupsById.get(contextGroupId);
+	            if (contextType === undefined) {
+	                // Send this single handler all of the context, because it accepts all.
+	                contextGroupMap.forEach((context, _) => {
+	                    this.invokeContextHandler(clientIdentity, handlerId, context);
+	                });
+	            }
+	            else if (contextGroupMap.has(contextType)) {
+	                const contextForType = contextGroupMap.get(contextType);
+	                if (contextForType) {
+	                    this.invokeContextHandler(clientIdentity, handlerId, contextForType);
+	                }
+	            }
+	        }
+	    }
+	    // eslint-disable-next-line class-methods-use-this
+	    async intentHandlerRegistered(payload, clientIdentity) {
+	        const { handlerId } = payload;
+	        const clientIntentInfo = this.intentClientMap.get(clientIdentity.name);
+	        const handlerInfo = clientIntentInfo?.get(handlerId);
+	        if (!clientIntentInfo) {
+	            this.intentClientMap.set(clientIdentity.name, new Map());
+	            const newHandlerInfoMap = this.intentClientMap.get(clientIdentity.name);
+	            if (newHandlerInfoMap) {
+	                newHandlerInfoMap.set(handlerId, { isReady: true, pendingIntents: [], clientIdentity });
+	            }
+	        }
+	        else if (!handlerInfo) {
+	            clientIntentInfo.set(handlerId, { isReady: true, pendingIntents: [], clientIdentity });
+	        }
+	        else {
+	            const { pendingIntents } = handlerInfo;
+	            handlerInfo.clientIdentity = clientIdentity;
+	            handlerInfo.isReady = true;
+	            try {
+	                if (pendingIntents.length > 0) {
+	                    const intentToSend = pendingIntents[pendingIntents.length - 1];
+	                    await this.invokeIntentHandler(clientIdentity, handlerId, intentToSend);
+	                    handlerInfo.pendingIntents = [];
+	                }
+	            }
+	            catch (error) {
+	                console.error(`Error invoking intent handler: ${handlerId} for client ${clientIdentity.uuid}/${clientIdentity.name}/${clientIdentity.endpointId}`);
+	            }
+	        }
+	    }
+	    // Used to remove a context handler for a client
+	    removeContextHandler({ handlerId }, clientIdentity) {
+	        const clientState = this.getClientState(clientIdentity);
+	        if (clientState) {
+	            clientState.contextHandlers.delete(handlerId);
+	        }
+	    }
+	    handleJoinSessionContextGroup({ sessionContextGroupId }, clientIdentity) {
+	        try {
+	            if (!sessionContextGroupId) {
+	                throw new Error('Failed to join session context group: must specify group id.');
+	            }
+	            const sessionContextGroup = this.sessionContextGroupMap.get(sessionContextGroupId);
+	            if (sessionContextGroup) {
+	                sessionContextGroup.registerNewClient(clientIdentity);
+	            }
+	            else {
+	                const newSessionContextGroupBroker = new SessionContextGroupBroker_1.default(this.channel, sessionContextGroupId);
+	                newSessionContextGroupBroker.registerNewClient(clientIdentity);
+	                this.sessionContextGroupMap.set(sessionContextGroupId, newSessionContextGroupBroker);
+	            }
+	            return { hasConflict: this.contextGroupsById.has(sessionContextGroupId) };
+	        }
+	        catch (error) {
+	            throw new Error(error);
+	        }
+	    }
+	    /*
+	    Internal Utilties
+	    */
+	    // Getter for interop info for a client.
+	    getClientState(id) {
+	        return this.interopClients.get(id.endpointId);
+	    }
+	    // Util for getContextGroupStates. Serializes the contextGroupStates object so we can store it.
+	    static toObject(map) {
+	        const objectFromMap = Object.fromEntries(map);
+	        const newObject = {};
+	        Object.entries(objectFromMap).forEach(([contextGroupId, contextMap]) => {
+	            const newContextObject = Object.fromEntries(contextMap);
+	            newObject[contextGroupId] = newContextObject;
+	        });
+	        return newObject;
+	    }
+	    static checkContextIntegrity(context) {
+	        if (!context) {
+	            return { isValid: false, reason: 'No context supplied' };
+	        }
+	        if (typeof context !== 'object') {
+	            return { isValid: false, reason: 'Context must be an Object' };
+	        }
+	        if (!context.type) {
+	            return { isValid: false, reason: 'Context must have a type property' };
+	        }
+	        if (context.id && typeof context.id !== 'object') {
+	            return {
+	                isValid: false,
+	                reason: 'Context id must be an Object populated with key-value identifiers (if set)'
+	            };
+	        }
+	        if (context.id) {
+	            const { id } = context;
+	            const keys = Object.keys(id);
+	            let foundBadIdentifier = false;
+	            if (!keys.length) {
+	                return { isValid: false, reason: 'Context id must have at least one key-value identifier' };
+	            }
+	            keys.forEach((key) => {
+	                if (typeof key !== 'string' || typeof id[key] !== 'string') {
+	                    foundBadIdentifier = true;
+	                }
+	            });
+	            if (foundBadIdentifier) {
+	                return { isValid: false, reason: 'Context id key-value identifiers must be of type string' };
+	            }
+	        }
+	        if (context.name && typeof context.name !== 'string') {
+	            return { isValid: false, reason: 'Context name must be of string type (if set)' };
+	        }
+	        return { isValid: true };
+	    }
+	    // Util to check a client identity.
+	    static hasEndpointId(target) {
+	        return target.endpointId !== undefined;
+	    }
+	    // Util to check if we should send a context to a handler.
+	    static isContextTypeCompatible(contextType, registeredContextType) {
+	        return typeof registeredContextType === 'undefined' || contextType === registeredContextType;
+	    }
+	    // Setup function for state mapping
+	    setContextGroupMap() {
+	        // This way, if a user overrides this.getContextGroups, it's reflected in the contextGroupMapping.
+	        for (const contextGroupInfo of this.getContextGroups()) {
+	            this.contextGroupsById.set(contextGroupInfo.id, new Map());
+	        }
+	    }
+	    async setCurrentContextGroupInClientOptions(clientIdentity, contextGroupId) {
+	        try {
+	            const entityInfo = await this.fin.System.getEntityInfo(clientIdentity.uuid, clientIdentity.name);
+	            let entity;
+	            if (entityInfo.entityType === 'view') {
+	                entity = await this.fin.View.wrap(clientIdentity);
+	            }
+	            else if (entityInfo.entityType === 'window') {
+	                entity = await this.fin.Window.wrap(clientIdentity);
+	            }
+	            if (entity) {
+	                await entity.updateOptions({
+	                    interop: {
+	                        currentContextGroup: contextGroupId
+	                    }
+	                });
+	            }
+	        }
+	        catch (error) {
+	            //  May file in interop
+	        }
+	    }
+	    async setupChannelProvider() {
+	        try {
+	            const channel = await this.getProvider();
+	            this.channel = channel;
+	            this.wireChannel(channel);
+	        }
+	        catch (error) {
+	            throw new Error(`Error setting up Interop Broker Channel Provider: ${error}`);
+	        }
+	    }
+	    // Setup Channel Connection Logic
+	    wireChannel(channel) {
+	        channel.onConnection(async (clientIdentity, // TODO(CORE-811): remove inline intersected type
+	        payload) => {
+	            if (!(await this.isConnectionAuthorized(clientIdentity, payload))) {
+	                throw new Error(`Connection not authorized for ${clientIdentity.uuid}, ${clientIdentity.name}`);
+	            }
+	            if (!clientIdentity.endpointId) {
+	                throw new Error('Version too old to be compatible with Interop. Please upgrade your runtime to a more recent version.');
+	            }
+	            const clientSubscriptionState = {
+	                contextGroupId: undefined,
+	                contextHandlers: new Map(),
+	                clientIdentity
+	            };
+	            // Only allow the client to join a contextGroup that actually exists.
+	            if (payload?.currentContextGroup && this.contextGroupsById.has(payload.currentContextGroup)) {
+	                clientSubscriptionState.contextGroupId = payload?.currentContextGroup;
+	            }
+	            this.interopClients.set(clientIdentity.endpointId, clientSubscriptionState);
+	        });
+	        channel.onDisconnection((clientIdentity) => {
+	            this.interopClients.delete(clientIdentity.endpointId);
+	            const targetInfo = this.intentClientMap.get(clientIdentity.name);
+	            if (targetInfo && clientIdentity.uuid === this.fin.me.uuid) {
+	                targetInfo.forEach((handler) => {
+	                    handler.isReady = false;
+	                });
+	            }
+	            this.sessionContextGroupMap.forEach((sessionContextGroup) => {
+	                sessionContextGroup.onDisconnection(clientIdentity);
+	            });
+	            this.clientDisconnected(clientIdentity);
+	        });
+	        channel.beforeAction(async (action, payload, clientIdentity) => {
+	            if (!(await this.isActionAuthorized(action, payload, clientIdentity))) {
+	                throw new Error(`Action (${action}) not authorized for ${clientIdentity.uuid}, ${clientIdentity.name}`);
+	            }
+	            if (this.logging?.beforeAction?.enabled) {
+	                console.log(action, payload, clientIdentity);
+	            }
+	        });
+	        channel.afterAction((action, payload, clientIdentity) => {
+	            if (this.logging?.afterAction?.enabled) {
+	                console.log(action, payload, clientIdentity);
+	            }
+	        });
+	        // Client functions
+	        channel.register('setContext', this.setContext.bind(this));
+	        channel.register('fireIntent', this.handleFiredIntent.bind(this));
+	        channel.register('getCurrentContext', this.getCurrentContext.bind(this));
+	        channel.register('getInfoForIntent', this.handleInfoForIntent.bind(this));
+	        channel.register('getInfoForIntentsByContext', this.handleInfoForIntentsByContext.bind(this));
+	        channel.register('fireIntentForContext', this.handleFiredIntentForContext.bind(this));
+	        // Platform window functions
+	        channel.register('getContextGroups', this.getContextGroups.bind(this));
+	        channel.register('joinContextGroup', this.joinContextGroup.bind(this));
+	        channel.register('removeFromContextGroup', this.removeFromContextGroup.bind(this));
+	        channel.register('getAllClientsInContextGroup', this.getAllClientsInContextGroup.bind(this));
+	        channel.register('getInfoForContextGroup', this.getInfoForContextGroup.bind(this));
+	        // Internal methods
+	        channel.register('contextHandlerRegistered', this.contextHandlerRegistered.bind(this));
+	        channel.register('intentHandlerRegistered', this.intentHandlerRegistered.bind(this));
+	        channel.register('removeContextHandler', this.removeContextHandler.bind(this));
+	        channel.register('sessionContextGroup:createIfNeeded', this.handleJoinSessionContextGroup.bind(this));
+	        // fdc3 only methods
+	        channel.register('fdc3Open', this.fdc3HandleOpen.bind(this));
+	        channel.register('fdc3v2FindIntentsByContext', this.handleInfoForIntentsByContext.bind(this));
+	        channel.register('fdc3FindInstances', this.fdc3HandleFindInstances.bind(this));
+	        channel.register('fdc3GetAppMetadata', this.fdc3HandleGetAppMetadata.bind(this));
+	        channel.register('fdc3v2GetInfo', async (payload, clientIdentity) => {
+	            return this.fdc3HandleGetInfo.bind(this)(payload, clientIdentity);
+	        });
+	        channel.register('createPrivateChannelProvider', async (payload) => {
+	            const { channelId } = payload;
+	            const channelProvider = await this.fin.InterApplicationBus.Channel.create(channelId);
+	            PrivateChannelProvider_1.PrivateChannelProvider.init(channelProvider, channelId);
+	        });
+	    }
+	    /**
+	     * Can be used to completely prevent a connection. Return false to prevent connections. Allows all connections by default.
+	     * @param _id the identity tryinc to connect
+	     * @param _connectionPayload optional payload to use in custom implementations, will be undefined by default
+	     */
+	    isConnectionAuthorized(_id, _connectionPayload) {
+	        this.wire.sendAction('interop-broker-is-connection-authorized').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        return Promise.resolve(true);
+	    }
+	    /**
+	     * Called before every action to check if this entity should be allowed to take the action.
+	     * Return false to prevent the action
+	     * @param _action the string action to authorize in camel case
+	     * @param _payload the data being sent for this action
+	     * @param _identity the connection attempting to dispatch this action
+	     */
+	    isActionAuthorized(_action, _payload, _identity) {
+	        this.wire.sendAction('interop-broker-is-action-authorized').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        return Promise.resolve(true);
+	    }
+	};
+	InteropBroker.InteropBroker = InteropBroker$1;
+	_InteropBroker_fdc3Info = new WeakMap(), _InteropBroker_contextGroups = new WeakMap(), _InteropBroker_providerPromise = new WeakMap();
+	return InteropBroker;
+}
+
+var InteropClient = {};
+
+var SessionContextGroupClient$1 = {};
+
+var __classPrivateFieldSet$2 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet$2 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _SessionContextGroupClient_clientPromise;
+Object.defineProperty(SessionContextGroupClient$1, "__esModule", { value: true });
+const base_1$2 = base;
+const utils_1$2 = utils$3;
+class SessionContextGroupClient extends base_1$2.Base {
+    constructor(wire, client, id) {
+        super(wire);
+        _SessionContextGroupClient_clientPromise.set(this, void 0);
+        this.id = id;
+        __classPrivateFieldSet$2(this, _SessionContextGroupClient_clientPromise, client, "f");
+    }
+    /**
+     * Sets a context for the session context group.
+     * @param context - New context to set.
+     *
+     * @tutorial interop.setContext
+     */
+    async setContext(context) {
+        this.wire.sendAction('interop-session-context-group-set-context').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const client = await __classPrivateFieldGet$2(this, _SessionContextGroupClient_clientPromise, "f");
+        return client.dispatch(`sessionContextGroup:setContext-${this.id}`, {
+            sessionContextGroupId: this.id,
+            context
+        });
+    }
+    async getCurrentContext(type) {
+        this.wire.sendAction('interop-session-context-group-get-context').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const client = await __classPrivateFieldGet$2(this, _SessionContextGroupClient_clientPromise, "f");
+        return client.dispatch(`sessionContextGroup:getContext-${this.id}`, {
+            sessionContextGroupId: this.id,
+            type
+        });
+    }
+    async addContextHandler(contextHandler, contextType) {
+        this.wire.sendAction('interop-session-context-group-add-handler').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        if (typeof contextHandler !== 'function') {
+            throw new Error("Non-function argument passed to the first parameter 'handler'. Be aware that the argument order does not match the FDC3 standard.");
+        }
+        const client = await __classPrivateFieldGet$2(this, _SessionContextGroupClient_clientPromise, "f");
+        let handlerId;
+        if (contextType) {
+            handlerId = `sessionContextHandler:invoke-${this.id}-${contextType}-${(0, utils_1$2.generateId)()}`;
+        }
+        else {
+            handlerId = `sessionContextHandler:invoke-${this.id}`;
+        }
+        client.register(handlerId, (0, utils_1$2.wrapContextHandler)(contextHandler, handlerId));
+        await client.dispatch(`sessionContextGroup:handlerAdded-${this.id}`, { handlerId, contextType });
+        return { unsubscribe: await this.createUnsubscribeCb(handlerId) };
+    }
+    async createUnsubscribeCb(handlerId) {
+        const client = await __classPrivateFieldGet$2(this, _SessionContextGroupClient_clientPromise, "f");
+        return async () => {
+            client.remove(handlerId);
+            await client.dispatch(`sessionContextGroup:handlerRemoved-${this.id}`, { handlerId });
+        };
+    }
+    getUserInstance() {
+        return {
+            id: this.id,
+            setContext: (0, utils_1$2.wrapInTryCatch)(this.setContext.bind(this), 'Failed to set context: '),
+            getCurrentContext: (0, utils_1$2.wrapInTryCatch)(this.getCurrentContext.bind(this), 'Failed to get context: '),
+            addContextHandler: (0, utils_1$2.wrapInTryCatch)(this.addContextHandler.bind(this), 'Failed to add context handler: ')
+        };
+    }
+}
+SessionContextGroupClient$1.default = SessionContextGroupClient;
+_SessionContextGroupClient_clientPromise = new WeakMap();
+
+var fdc31_2 = {};
+
+var fdc3Common = {};
+
+var utils$2 = {};
+
+var PrivateChannelClient$1 = {};
+
+var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (commonjsGlobal && commonjsGlobal.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (commonjsGlobal && commonjsGlobal.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(PrivateChannelClient$1, "__esModule", { value: true });
+PrivateChannelClient$1.PrivateChannelClient = void 0;
+const utils$1 = __importStar(utils$3);
+class PrivateChannelClient {
+    constructor(client, id) {
+        this.id = id;
+        this.client = client;
+        this.listeners = new Map();
+    }
+    async broadcast(context) {
+        return this.client.dispatch('broadcast', { context });
+    }
+    async getCurrentContext(contextType) {
+        return this.client.dispatch('getCurrentContext', { contextType });
+    }
+    async addContextListener(contextType, handler) {
+        if (typeof handler !== 'function') {
+            throw new Error("Non-function argument passed to the second parameter 'handler'. Be aware that the argument order does not match the FDC3 standard.");
+        }
+        let handlerId;
+        if (contextType) {
+            handlerId = `contextHandler:invoke-${this.id}-${contextType}-${utils$1.generateId()}`;
+        }
+        else {
+            handlerId = `contextHandler:invoke-${this.id}-${utils$1.generateId()}`;
+        }
+        this.client.register(handlerId, utils$1.wrapContextHandler(handler, handlerId));
+        const listener = { unsubscribe: await this.createContextUnsubscribeCb(handlerId) };
+        this.listeners.set(handlerId, listener);
+        await this.client.dispatch(`contextHandlerAdded`, { handlerId, contextType });
+        return listener;
+    }
+    createNonStandardUnsubscribeCb(handlerId) {
+        return async () => {
+            this.client.remove(handlerId);
+            this.listeners.delete(handlerId);
+            await this.client.dispatch('nonStandardHandlerRemoved', { handlerId });
+        };
+    }
+    createContextUnsubscribeCb(handlerId) {
+        return async () => {
+            this.client.remove(handlerId);
+            this.listeners.delete(handlerId);
+            await this.client.dispatch('contextHandlerRemoved', { handlerId });
+        };
+    }
+    onAddContextListener(handler) {
+        const handlerId = `onContextHandlerAdded:invoke-${this.id}-${utils$1.generateId()}`;
+        this.client.register(handlerId, handler);
+        const listener = { unsubscribe: this.createNonStandardUnsubscribeCb(handlerId) };
+        this.listeners.set(handlerId, listener);
+        this.client.dispatch(`onAddContextHandlerAdded`, { handlerId });
+        return listener;
+    }
+    onDisconnect(handler) {
+        const handlerId = `onDisconnect:invoke-${this.id}-${utils$1.generateId()}`;
+        this.client.register(handlerId, handler);
+        const listener = { unsubscribe: this.createNonStandardUnsubscribeCb(handlerId) };
+        this.listeners.set(handlerId, listener);
+        this.client.dispatch(`onDisconnectHandlerAdded`, { handlerId });
+        return listener;
+    }
+    onUnsubscribe(handler) {
+        const handlerId = `onUnsubscribe:invoke-${this.id}-${utils$1.generateId()}`;
+        this.client.register(handlerId, handler);
+        const listener = { unsubscribe: this.createNonStandardUnsubscribeCb(handlerId) };
+        this.listeners.set(handlerId, listener);
+        this.client.dispatch(`onUnsubscribeHandlerAdded`, { handlerId });
+        return listener;
+    }
+    async cleanUpAllSubs() {
+        const listenerUnsubscribers = Array.from(this.listeners.keys());
+        listenerUnsubscribers.forEach((handlerId) => {
+            this.client.remove(handlerId);
+            this.listeners.delete(handlerId);
+        });
+    }
+    async disconnect() {
+        try {
+            await this.client.dispatch('clientDisconnecting');
+            await this.cleanUpAllSubs();
+            await this.client.disconnect();
+        }
+        catch (error) {
+            throw new Error(error.message);
+        }
+    }
+}
+PrivateChannelClient$1.PrivateChannelClient = PrivateChannelClient;
+
+(function (exports) {
+	var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+	    return (mod && mod.__esModule) ? mod : { "default": mod };
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.getIntentResolution = exports.isChannel = exports.isContext = exports.connectPrivateChannel = exports.buildAppChannelObject = exports.buildPrivateChannelObject = exports.ChannelError = exports.ResultError = exports.UnsupportedChannelApiError = exports.getUnsupportedChannelApis = void 0;
+	const utils_1 = utils$3;
+	const PrivateChannelClient_1 = PrivateChannelClient$1;
+	const isEqual_1 = __importDefault(require$$3);
+	const getUnsupportedChannelApis = (channelType) => {
+	    return {
+	        addContextListener: () => {
+	            throw new UnsupportedChannelApiError('Channel.addContextListener', channelType);
+	        },
+	        broadcast: () => {
+	            throw new UnsupportedChannelApiError('Channel.broadcast', channelType);
+	        },
+	        getCurrentContext: () => {
+	            throw new UnsupportedChannelApiError('Channel.getCurrentContext', channelType);
+	        }
+	    };
+	};
+	exports.getUnsupportedChannelApis = getUnsupportedChannelApis;
+	class UnsupportedChannelApiError extends Error {
+	    constructor(apiName, channelType = 'System') {
+	        super(apiName);
+	        this.message = `Calling ${apiName} on an instance of a ${channelType} Channel returned by fdc3.get${channelType}Channels is not supported. If you would like to use a ${channelType} Channel, please use fdc3.joinChannel, fdc3.addContextListener, and fdc3.broadcast instead.`;
+	    }
+	}
+	exports.UnsupportedChannelApiError = UnsupportedChannelApiError;
+	var ResultError;
+	(function (ResultError) {
+	    /** Returned if the `IntentHandler` exited without returning a Promise or that
+	     *  Promise was not resolved with a Context or Channel object.
+	     */
+	    ResultError["NoResultReturned"] = "NoResultReturned";
+	    /** Returned if the `IntentHandler` function processing the raised intent
+	     *  throws an error or rejects the Promise it returned.
+	     */
+	    ResultError["IntentHandlerRejected"] = "IntentHandlerRejected";
+	})(ResultError = exports.ResultError || (exports.ResultError = {}));
+	(function (ChannelError) {
+	    /** Returned if the specified channel is not found when attempting to join a
+	     *  channel via the `joinUserChannel` function of the DesktopAgent (`fdc3`).
+	     */
+	    ChannelError["NoChannelFound"] = "NoChannelFound";
+	    /** SHOULD be returned when a request to join a user channel or to a retrieve
+	     *  a Channel object via the `joinUserChannel` or `getOrCreateChannel` methods
+	     *  of the DesktopAgent (`fdc3`) object is denied.
+	     */
+	    ChannelError["AccessDenied"] = "AccessDenied";
+	    /** SHOULD be returned when a channel cannot be created or retrieved via the
+	     *  `getOrCreateChannel` method of the DesktopAgent (`fdc3`).
+	     */
+	    ChannelError["CreationFailed"] = "CreationFailed";
+	})(exports.ChannelError || (exports.ChannelError = {}));
+	const buildPrivateChannelObject = (privateChannelClient) => {
+	    let clientDisconnected = false;
+	    const checkIfClientDisconnected = () => {
+	        if (clientDisconnected) {
+	            throw new Error('Private Channel Client has been disconnected from the Private Channel');
+	        }
+	    };
+	    return {
+	        id: privateChannelClient.id,
+	        type: 'private',
+	        broadcast: async (context) => {
+	            checkIfClientDisconnected();
+	            return privateChannelClient.broadcast(context);
+	        },
+	        getCurrentContext: async (contextType) => {
+	            checkIfClientDisconnected();
+	            return privateChannelClient.getCurrentContext(contextType);
+	        },
+	        // @ts-expect-error TODO [CORE-1524]
+	        addContextListener: async (contextType, handler) => {
+	            checkIfClientDisconnected();
+	            let handlerInUse = handler;
+	            let contextTypeInUse = contextType;
+	            if (typeof contextType === 'function') {
+	                console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');
+	                handlerInUse = contextType;
+	                contextTypeInUse = null;
+	            }
+	            const listener = privateChannelClient.addContextListener(contextTypeInUse, handlerInUse);
+	            return listener;
+	        },
+	        onAddContextListener: (handler) => {
+	            checkIfClientDisconnected();
+	            return privateChannelClient.onAddContextListener(handler);
+	        },
+	        disconnect: async () => {
+	            checkIfClientDisconnected();
+	            clientDisconnected = true;
+	            return privateChannelClient.disconnect();
+	        },
+	        onDisconnect: (handler) => {
+	            checkIfClientDisconnected();
+	            return privateChannelClient.onDisconnect(handler);
+	        },
+	        onUnsubscribe: (handler) => {
+	            checkIfClientDisconnected();
+	            return privateChannelClient.onUnsubscribe(handler);
+	        }
+	    };
+	};
+	exports.buildPrivateChannelObject = buildPrivateChannelObject;
+	const buildAppChannelObject = (sessionContextGroup) => {
+	    return {
+	        id: sessionContextGroup.id,
+	        type: 'app',
+	        broadcast: sessionContextGroup.setContext,
+	        getCurrentContext: async (contextType) => {
+	            const context = await sessionContextGroup.getCurrentContext(contextType);
+	            return context === undefined ? null : context;
+	        },
+	        // @ts-expect-error TODO [CORE-1524]
+	        addContextListener: (contextType, handler) => {
+	            let realHandler;
+	            let realType;
+	            if (typeof contextType === 'function') {
+	                console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');
+	                realHandler = contextType;
+	            }
+	            else {
+	                realHandler = handler;
+	                if (typeof contextType === 'string') {
+	                    realType = contextType;
+	                }
+	            }
+	            const listener = (async () => {
+	                let first = true;
+	                const currentContext = await sessionContextGroup.getCurrentContext(realType);
+	                const wrappedHandler = (context, contextMetadata) => {
+	                    if (first) {
+	                        first = false;
+	                        if ((0, isEqual_1.default)(currentContext, context)) {
+	                            return;
+	                        }
+	                    }
+	                    // eslint-disable-next-line consistent-return
+	                    return realHandler(context, contextMetadata);
+	                };
+	                return sessionContextGroup.addContextHandler(wrappedHandler, realType);
+	            })();
+	            return {
+	                ...listener,
+	                unsubscribe: () => listener.then((l) => l.unsubscribe())
+	            };
+	        }
+	    };
+	};
+	exports.buildAppChannelObject = buildAppChannelObject;
+	const connectPrivateChannel = async (channelId) => {
+	    try {
+	        const channelClient = await fin.InterApplicationBus.Channel.connect(channelId);
+	        const privateChannelClient = new PrivateChannelClient_1.PrivateChannelClient(channelClient, channelId);
+	        return (0, exports.buildPrivateChannelObject)(privateChannelClient);
+	    }
+	    catch (error) {
+	        throw new Error(`Private Channel with id: ${channelId} doesn't exist`);
+	    }
+	};
+	exports.connectPrivateChannel = connectPrivateChannel;
+	const isContext = (context) => {
+	    if (context && typeof context === 'object' && 'type' in context) {
+	        const { type } = context;
+	        return typeof type === 'string';
+	    }
+	    return false;
+	};
+	exports.isContext = isContext;
+	const isChannel = (channel) => {
+	    if (channel && typeof channel === 'object' && 'type' in channel && 'id' in channel) {
+	        const { type, id } = channel;
+	        return typeof type === 'string' && typeof id === 'string' && (type === 'app' || type === 'private');
+	    }
+	    return false;
+	};
+	exports.isChannel = isChannel;
+	const getIntentResolution = async (interopModule, context, app, intent) => {
+	    // Generate an ID to make a session context group with. We will pass that ID to the Broker.
+	    // The broker will then setContext on that session context group later with our Intent Result,
+	    const guid = (0, utils_1.generateId)(); // TODO make this undefined in web
+	    // Promise we'll use in getResult
+	    const getResultPromise = new Promise((resolve, reject) => {
+	        fin.InterApplicationBus.subscribe({ uuid: '*' }, guid, (intentResult) => {
+	            resolve(intentResult);
+	        }).catch(() => reject(new Error('getResult is not supported in this environment')));
+	    });
+	    // Adding the intentResolutionResultId to the intentObj. Because fireIntent only accepts a single arg, we have to slap it in here.
+	    const metadata = app ? { target: app, intentResolutionResultId: guid } : { intentResolutionResultId: guid };
+	    const intentObj = intent ? { name: intent, context, metadata } : { ...context, metadata };
+	    // Set up the getResult call.
+	    const getResult = async () => {
+	        let intentResult = await getResultPromise;
+	        if (!intentResult || typeof intentResult !== 'object') {
+	            throw new Error(ResultError.NoResultReturned);
+	        }
+	        const { error } = intentResult;
+	        if (error) {
+	            throw new Error(ResultError.IntentHandlerRejected);
+	        }
+	        if ((0, exports.isChannel)(intentResult)) {
+	            const { id, type } = intentResult;
+	            switch (type) {
+	                case 'private': {
+	                    intentResult = await (0, exports.connectPrivateChannel)(id);
+	                    break;
+	                }
+	                case 'app': {
+	                    const sessionContextGroup = await interopModule.joinSessionContextGroup(id);
+	                    intentResult = (0, exports.buildAppChannelObject)(sessionContextGroup);
+	                    break;
+	                }
+	            }
+	        }
+	        else if (!(0, exports.isContext)(intentResult)) {
+	            throw new Error(ResultError.NoResultReturned);
+	        }
+	        return intentResult;
+	    };
+	    // Finally fire the intent.
+	    const intentResolutionInfoFromBroker = intent
+	        ? await interopModule.fireIntent(intentObj)
+	        : await interopModule.fireIntentForContext(intentObj);
+	    if (typeof intentResolutionInfoFromBroker !== 'object') {
+	        return {
+	            source: {
+	                appId: '',
+	                instanceId: ''
+	            },
+	            intent: '',
+	            version: '2.0',
+	            getResult
+	        };
+	    }
+	    return { ...intentResolutionInfoFromBroker, getResult };
+	};
+	exports.getIntentResolution = getIntentResolution; 
+} (utils$2));
+
+var hasRequiredFdc3Common;
+
+function requireFdc3Common () {
+	if (hasRequiredFdc3Common) return fdc3Common;
+	hasRequiredFdc3Common = 1;
+	var __classPrivateFieldGet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+	    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+	    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+	    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+	};
+	var __classPrivateFieldSet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+	    if (kind === "m") throw new TypeError("Private method is not writable");
+	    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+	    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+	    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+	};
+	var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+	    return (mod && mod.__esModule) ? mod : { "default": mod };
+	};
+	var _FDC3ModuleBase_producer;
+	Object.defineProperty(fdc3Common, "__esModule", { value: true });
+	fdc3Common.FDC3ModuleBase = void 0;
+	const utils_1 = utils$2;
+	const utils_2 = utils$3;
+	const InteropClient_1 = requireInteropClient();
+	const isEqual_1 = __importDefault(require$$3);
+	class FDC3ModuleBase {
+	    get client() {
+	        return __classPrivateFieldGet(this, _FDC3ModuleBase_producer, "f").call(this);
+	    }
+	    get fin() {
+	        return this.wire.getFin();
+	    }
+	    // eslint-disable-next-line no-useless-constructor
+	    constructor(producer, wire) {
+	        this.wire = wire;
+	        _FDC3ModuleBase_producer.set(this, void 0);
+	        __classPrivateFieldSet(this, _FDC3ModuleBase_producer, producer, "f");
+	    }
+	    /**
+	     * Broadcasts a context for the channel of the current entity.
+	     * @param context - New context to set.
+	     *
+	     * @tutorial fdc3.broadcast
+	     * @static
+	     */
+	    async broadcast(context) {
+	        this.wire.sendAction('fdc3-broadcast').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        return this.client.setContext(context);
+	    }
+	    /**
+	     * Launches an app with target information, which can either be a string or an AppMetadata object.
+	     * @param app
+	     * @param context
+	     *
+	     * @tutorial fdc3.open
+	     */
+	    async _open(app, context) {
+	        this.wire.sendAction('fdc3-open').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        try {
+	            return await InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'fdc3Open', { app, context });
+	        }
+	        catch (error) {
+	            const errorToThrow = error.message === utils_2.BROKER_ERRORS.fdc3Open ? 'ResolverUnavailable' : error.message;
+	            throw new Error(errorToThrow);
+	        }
+	    }
+	    async _getChannels() {
+	        const channels = await this.client.getContextGroups();
+	        // fdc3 implementation of getSystemChannels returns an array of channels, have to decorate over
+	        // this so people know that these APIs are not supported
+	        return channels.map((channel) => {
+	            return { ...channel, type: 'system', ...(0, utils_1.getUnsupportedChannelApis)() };
+	        });
+	    }
+	    /**
+	     * Returns a Channel object for the specified channel, creating it as an App Channel if it does not exist.
+	     * @param channelId
+	     *
+	     * @tutorial fdc3.getOrCreateChannel
+	     */
+	    async getOrCreateChannel(channelId) {
+	        this.wire.sendAction('fdc3-get-or-create-channel').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        const systemChannels = await this._getChannels();
+	        const userChannel = systemChannels.find((channel) => channel.id === channelId);
+	        if (userChannel) {
+	            return { ...userChannel, type: 'system', ...(0, utils_1.getUnsupportedChannelApis)() };
+	        }
+	        try {
+	            const sessionContextGroup = await this.client.joinSessionContextGroup(channelId);
+	            return (0, utils_1.buildAppChannelObject)(sessionContextGroup);
+	        }
+	        catch (error) {
+	            console.error(error.message);
+	            throw new Error(utils_1.ChannelError.CreationFailed);
+	        }
+	    }
+	    /**
+	     * Returns the Interop-Broker-defined context groups available for an entity to join.
+	     *
+	     * @tutorial fdc3.getSystemChannels
+	     * @static
+	     */
+	    async getSystemChannels() {
+	        this.wire.sendAction('fdc3-get-system-channels').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        return this._getChannels();
+	    }
+	    /**
+	     * Join all Interop Clients at the given identity to context group `contextGroupId`.
+	     * If no target is specified, it adds the sender to the context group.
+	     * Because multiple Channel connections/Interop Clients can potentially exist at a `uuid`/`name` combo, we currently join all Channel connections/Interop Clients at the given identity to the context group.
+	     * If an `endpointId` is provided (which is unlikely, unless the call is coming from an external adapter), then we only join that single connection to the context group.
+	     * For all intents and purposes, there will only be 1 connection present in Platform and Browser implementations, so this point is more-or-less moot.
+	     * @param channelId - Id of the context group.
+	     *
+	     * @tutorial fdc3.joinChannel
+	     * @static
+	     */
+	    async joinChannel(channelId) {
+	        this.wire.sendAction('fdc3-join-channel').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        try {
+	            return await this.client.joinContextGroup(channelId);
+	        }
+	        catch (error) {
+	            if (error.message === utils_2.BROKER_ERRORS.joinSessionContextGroupWithJoinContextGroup) {
+	                console.error('The Channel you have tried to join is an App Channel. Custom Channels can only be defined by the Interop Broker through code or manifest configuration. Please use getOrCreateChannel.');
+	            }
+	            else {
+	                console.error(error.message);
+	            }
+	            if (error.message.startsWith('Attempting to join a context group that does not exist')) {
+	                throw new Error(utils_1.ChannelError.NoChannelFound);
+	            }
+	            throw new Error(utils_1.ChannelError.AccessDenied);
+	        }
+	    }
+	    /**
+	     * Returns the Channel that the entity is subscribed to. Returns null if not joined to a channel.
+	     *
+	     * @tutorial fdc3.getCurrentChannel
+	     */
+	    async getCurrentChannel() {
+	        this.wire.sendAction('fdc3-get-current-channel').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        const currentContextGroupInfo = await this.getCurrentContextGroupInfo();
+	        if (!currentContextGroupInfo) {
+	            return null;
+	        }
+	        return this.buildChannelObject(currentContextGroupInfo);
+	    }
+	    /**
+	     * Removes the specified target from a context group.
+	     * If no target is specified, it removes the sender from their context group.
+	     *
+	     * @tutorial fdc3.leaveCurrentChannel
+	     * @static
+	     */
+	    async leaveCurrentChannel() {
+	        this.wire.sendAction('fdc3-leave-current-channel').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        return this.client.removeFromContextGroup();
+	    }
+	    // utils
+	    // eslint-disable-next-line class-methods-use-this
+	    async getCurrentContextGroupInfo() {
+	        const contextGroups = await this.client.getContextGroups();
+	        const clientsInCtxGroupsPromise = contextGroups.map(async (ctxGroup) => {
+	            return this.client.getAllClientsInContextGroup(ctxGroup.id);
+	        });
+	        const clientsInCtxGroups = await Promise.all(clientsInCtxGroupsPromise);
+	        const clientIdx = clientsInCtxGroups.findIndex((clientIdentityArr) => {
+	            return clientIdentityArr.some((clientIdentity) => {
+	                const { uuid, name } = clientIdentity;
+	                return this.wire.me.uuid === uuid && this.wire.me.name === name;
+	            });
+	        });
+	        return contextGroups[clientIdx];
+	    }
+	    async buildChannelObject(currentContextGroupInfo) {
+	        // @ts-expect-error
+	        return {
+	            ...currentContextGroupInfo,
+	            type: 'system',
+	            addContextListener: (...[contextType, handler]) => {
+	                let realHandler;
+	                let realType;
+	                if (typeof contextType === 'function') {
+	                    console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');
+	                    realHandler = contextType;
+	                }
+	                else {
+	                    realHandler = handler;
+	                    if (typeof contextType === 'string') {
+	                        realType = contextType;
+	                    }
+	                }
+	                const listener = (async () => {
+	                    let first = true;
+	                    const currentContext = await this.client.getCurrentContext(realType);
+	                    const wrappedHandler = (context, contextMetadata) => {
+	                        if (first) {
+	                            first = false;
+	                            if ((0, isEqual_1.default)(currentContext, context)) {
+	                                return;
+	                            }
+	                        }
+	                        // eslint-disable-next-line consistent-return
+	                        return realHandler(context, contextMetadata);
+	                    };
+	                    return this.client.addContextHandler(wrappedHandler, realType);
+	                })();
+	                // @ts-expect-error TODO [CORE-1524]
+	                return {
+	                    ...listener,
+	                    unsubscribe: () => listener.then((l) => l.unsubscribe())
+	                };
+	            },
+	            broadcast: this.broadcast.bind(this),
+	            // @ts-expect-error Typescript fails to infer the returntype is a Promise
+	            getCurrentContext: async (contextType) => {
+	                const context = await this.client.getCurrentContext(contextType);
+	                // @ts-expect-error Typescript fails to infer the returntype is a Promise
+	                return context === undefined ? null : context;
+	            }
+	        };
+	    }
+	}
+	fdc3Common.FDC3ModuleBase = FDC3ModuleBase;
+	_FDC3ModuleBase_producer = new WeakMap();
+	return fdc3Common;
+}
+
+var hasRequiredFdc31_2;
+
+function requireFdc31_2 () {
+	if (hasRequiredFdc31_2) return fdc31_2;
+	hasRequiredFdc31_2 = 1;
+	Object.defineProperty(fdc31_2, "__esModule", { value: true });
+	fdc31_2.Fdc3Module = void 0;
+	const utils_1 = utils$3;
+	const fdc3_common_1 = requireFdc3Common();
+	/**
+	 * @version 1.2
+	 * The FDC3 Client Library provides a set APIs to be used for FDC3 compliance,
+	 * while using our Interop API under the hood. In order to use this set of APIs
+	 * you will need to set up your own {@link InteropBroker InteropBroker} or use a Platform application, which does the setup for you. Refer to our documentation on
+	 * our {@link https://developers.openfin.co/of-docs/docs/enable-color-linking Interop API}.
+	 *
+	 * To enable the FDC3 APIs in a {@link Window Window} or {@link View View}, add the fdc3InteropApi
+	 * property to its options:
+	 *
+	 * ```js
+	 * {
+	 *     autoShow: false,
+	 *     saveWindowState: true,
+	 *     url: 'https://openfin.co',
+	 *     fdc3InteropApi: '1.2'
+	 * }
+	 * ```
+	 *
+	 * If using a {@link Platform Platform } application, you can set this property in defaultWindowOptions and defaultViewOptions.
+	 *
+	 * In order to ensure that the FDC3 Api is ready before use, you can use the 'fdc3Ready' event fired on the DOM Window object:
+	 *
+	 * ```js
+	 * function fdc3Action() {
+	 *     // Make some fdc3 API calls here
+	 * }
+	 *
+	 * if (window.fdc3) {
+	 *    fdc3Action();
+	 * } else {
+	 *    window.addEventListener('fdc3Ready', fdc3Action);
+	 * }
+	 * ```
+	 */
+	class Fdc3Module extends fdc3_common_1.FDC3ModuleBase {
+	    async open(app, context) {
+	        // eslint-disable-next-line no-underscore-dangle
+	        await super._open(app, context);
+	    }
+	    /**
+	     * Add a context handler for incoming context. If an entity is part of a context group, and then sets its context handler, it will receive all of its declared contexts. If you wish to listen for all incoming contexts, pass `null` for the contextType argument.
+	     * @param contextType - The type of context you wish to handle.
+	     * @param handler - Handler for incoming context.
+	     *
+	     * @tutorial fdc3.addContextListener
+	     * @static
+	     */
+	    // @ts-expect-error TODO [CORE-1524]
+	    addContextListener(contextType, handler) {
+	        this.wire.sendAction('fdc3-add-context-listener').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        let listener;
+	        if (typeof contextType === 'function') {
+	            console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');
+	            listener = this.client.addContextHandler(contextType);
+	        }
+	        else {
+	            listener = this.client.addContextHandler(handler, contextType === null ? undefined : contextType);
+	        }
+	        return {
+	            ...listener,
+	            unsubscribe: () => listener.then((l) => l.unsubscribe())
+	        };
+	    }
+	    /**
+	     * Adds a listener for incoming Intents.
+	     * @param intent - Name of the Intent
+	     * @param handler - Handler for incoming Intent
+	     *
+	     * @tutorial fdc3.addIntentListener
+	     * @static
+	     */
+	    addIntentListener(intent, handler) {
+	        this.wire.sendAction('fdc3-add-intent-listener').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        const contextHandler = (raisedIntent) => {
+	            const { context, metadata: intentMetadata } = raisedIntent;
+	            const { metadata } = context;
+	            const intentResolutionResultId = intentMetadata?.intentResolutionResultId || metadata?.intentResolutionResultId;
+	            if (intentResolutionResultId) {
+	                this.fin.InterApplicationBus.publish(intentResolutionResultId, null).catch(() => null);
+	            }
+	            handler(raisedIntent.context);
+	        };
+	        const listener = this.client.registerIntentHandler(contextHandler, intent, {
+	            fdc3Version: '1.2'
+	        });
+	        return {
+	            ...listener,
+	            unsubscribe: () => listener.then((l) => l.unsubscribe())
+	        };
+	    }
+	    /**
+	     * Raises a specific intent.
+	     * @param intent Name of the Intent.
+	     * @param context Context associated with the Intent.
+	     * @param  app App that will resolve the Intent. This is added as metadata to the Intent. Can be accessed by the app provider in {@link InteropBroker#handleFiredIntent InteropBroker.handleFiredIntent}.
+	     *
+	     * @tutorial fdc3.raiseIntent
+	     * @static
+	     */
+	    async raiseIntent(intent, context, app) {
+	        this.wire.sendAction('fdc3-raise-intent').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        const intentObj = app
+	            ? { name: intent, context, metadata: { target: app } }
+	            : { name: intent, context };
+	        try {
+	            return await this.client.fireIntent(intentObj);
+	        }
+	        catch (error) {
+	            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fireIntent ? 'ResolverUnavailable' : error.message;
+	            throw new Error(errorToThrow);
+	        }
+	    }
+	    /**
+	     * Find out more information about a particular intent by passing its name, and optionally its context.
+	     * @param intent Name of the Intent
+	     * @param context
+	     *
+	     * @tutorial fdc3.findIntent
+	     */
+	    async findIntent(intent, context) {
+	        this.wire.sendAction('fdc3-find-intent').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        try {
+	            return await this.client.getInfoForIntent({ name: intent, context });
+	        }
+	        catch (error) {
+	            const errorToThrow = error.message === utils_1.BROKER_ERRORS.getInfoForIntent ? 'ResolverUnavailable' : error.message;
+	            throw new Error(errorToThrow);
+	        }
+	    }
+	    /**
+	     * Find all the available intents for a particular context.
+	     * @param context
+	     *
+	     * @tutorial fdc3.findIntentsByContext
+	     */
+	    async findIntentsByContext(context) {
+	        this.wire.sendAction('fdc3-find-intents-by-context').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        try {
+	            return await this.client.getInfoForIntentsByContext(context);
+	        }
+	        catch (error) {
+	            const errorToThrow = error.message === utils_1.BROKER_ERRORS.getInfoForIntentsByContext ? 'ResolverUnavailable' : error.message;
+	            throw new Error(errorToThrow);
+	        }
+	    }
+	    /**
+	     * Finds and raises an intent against a target app based purely on context data.
+	     * @param context
+	     * @param app
+	     *
+	     * @tutorial fdc3.raiseIntentForContext
+	     */
+	    async raiseIntentForContext(context, app) {
+	        this.wire.sendAction('fdc3-raise-intent-for-context').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        try {
+	            return await this.client.fireIntentForContext({ ...context, metadata: { target: app } });
+	        }
+	        catch (error) {
+	            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fireIntentForContext ? 'ResolverUnavailable' : error.message;
+	            throw new Error(errorToThrow);
+	        }
+	    }
+	    /**
+	     * Returns a Channel object for the specified channel, creating it as an App Channel if it does not exist.
+	     * @param channelId
+	     *
+	     * @tutorial fdc3.getOrCreateChannel
+	     */
+	    async getOrCreateChannel(channelId) {
+	        return super.getOrCreateChannel(channelId);
+	    }
+	    /**
+	     * Returns metadata relating to the FDC3 object and its provider, including the supported version of the FDC3 specification and the name of the provider of the implementation.
+	     *
+	     * @tutorial fdc3.getInfo
+	     */
+	    getInfo() {
+	        this.wire.sendAction('fdc3-get-info').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        const version = this.wire.environment.getAdapterVersionSync();
+	        return {
+	            providerVersion: version,
+	            provider: `openfin-${this.wire.me.uuid}`,
+	            fdc3Version: '1.2'
+	        };
+	    }
+	}
+	fdc31_2.Fdc3Module = Fdc3Module;
+	return fdc31_2;
+}
+
+var fdc32_0 = {};
+
+var hasRequiredFdc32_0;
+
+function requireFdc32_0 () {
+	if (hasRequiredFdc32_0) return fdc32_0;
+	hasRequiredFdc32_0 = 1;
+	Object.defineProperty(fdc32_0, "__esModule", { value: true });
+	fdc32_0.Fdc3Module2 = void 0;
+	const fdc3_common_1 = requireFdc3Common();
+	const utils_1 = utils$3;
+	const InteropClient_1 = requireInteropClient();
+	const utils_2 = utils$2;
+	const PrivateChannelClient_1 = PrivateChannelClient$1;
+	/**
+	 * @version 2.0
+	 * The FDC3 Client Library provides a set APIs to be used for FDC3 compliance,
+	 * while using our Interop API under the hood. In order to use this set of APIs
+	 * you will need to set up your own {@link InteropBroker InteropBroker} or use a Platform application, which does the setup for you. Refer to our documentation on
+	 * our {@link https://developers.openfin.co/of-docs/docs/enable-context-sharing Interop API}.
+	 *
+	 * To enable the FDC3 APIs in a {@link Window Window} or {@link View View}, add the fdc3InteropApi
+	 * property to its options:
+	 *
+	 * ```js
+	 * {
+	 *     autoShow: false,
+	 *     saveWindowState: true,
+	 *     url: 'https://openfin.co',
+	 *     fdc3InteropApi: '2.0'
+	 * }
+	 * ```
+	 *
+	 * If using a {@link Platform Platform } application, you can set this property in defaultWindowOptions and defaultViewOptions.
+	 *
+	 * In order to ensure that the FDC3 Api is ready before use, you can use the 'fdc3Ready' event fired on the DOM Window object:
+	 *
+	 * ```js
+	 * function fdc3Action() {
+	 *     // Make some fdc3 API calls here
+	 * }
+	 *
+	 * if (window.fdc3) {
+	 *    fdc3Action();
+	 * } else {
+	 *    window.addEventListener('fdc3Ready', fdc3Action);
+	 * }
+	 * ```
+	 */
+	class Fdc3Module2 extends fdc3_common_1.FDC3ModuleBase {
+	    /**
+	     * Launches an app, specified via an AppIdentifier object.
+	     * @param app
+	     * @param context
+	     *
+	     * @tutorial fdc3.open
+	     */
+	    async open(app, context) {
+	        if (typeof app === 'string') {
+	            console.warn('Passing a string as the app parameter is deprecated, please use an AppIdentifier ({ appId: string; instanceId?: string }).');
+	        }
+	        // eslint-disable-next-line no-underscore-dangle
+	        return super._open(app, context);
+	    }
+	    /**
+	     * Find all the available instances for a particular application.
+	     * @param app
+	     *
+	     * @tutorial fdc3v2.findInstances
+	     */
+	    async findInstances(app) {
+	        this.wire.sendAction('fdc3-find-instances').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        try {
+	            return await InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'fdc3FindInstances', app);
+	        }
+	        catch (error) {
+	            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fdc3FindInstances ? 'ResolverUnavailable' : error.message;
+	            throw new Error(errorToThrow);
+	        }
+	    }
+	    /**
+	     * Retrieves the AppMetadata for an AppIdentifier, which provides additional metadata (such as icons, a title and description) from the App Directory record for the application, that may be used for display purposes.
+	     * @param app
+	     *
+	     * @tutorial fdc3v2.getAppMetadata
+	     */
+	    async getAppMetadata(app) {
+	        this.wire.sendAction('fdc3-get-app-metadata').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        try {
+	            return await InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'fdc3GetAppMetadata', app);
+	        }
+	        catch (error) {
+	            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fdc3GetAppMetadata ? 'ResolverUnavailable' : error.message;
+	            throw new Error(errorToThrow);
+	        }
+	    }
+	    /**
+	     * Add a context handler for incoming context. If an entity is part of a context group, and then sets its context handler, it will receive all of its declared contexts. If you wish to listen for all incoming contexts, pass `null` for the contextType argument.
+	     * @param contextType
+	     * @param handler
+	     *
+	     * @tutorial fdc3.addContextListener
+	     */
+	    // @ts-expect-error TODO [CORE-1524]
+	    async addContextListener(contextType, handler) {
+	        this.wire.sendAction('fdc3-add-context-listener').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        // The FDC3 ContextHandler only expects the context and optional ContextMetadata, so we wrap the handler
+	        // here so it only gets passed these parameters
+	        const getWrappedHandler = (handlerToWrap) => {
+	            return (context) => {
+	                const { contextMetadata, ...rest } = context;
+	                const args = contextMetadata ? [{ ...rest }, contextMetadata] : [context, null];
+	                handlerToWrap(...args);
+	            };
+	        };
+	        let actualHandler = handler;
+	        let wrappedHandler = getWrappedHandler(actualHandler);
+	        if (typeof contextType === 'function') {
+	            console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');
+	            actualHandler = contextType;
+	            wrappedHandler = getWrappedHandler(actualHandler);
+	            return this.client.addContextHandler(wrappedHandler);
+	        }
+	        return this.client.addContextHandler(wrappedHandler, contextType === null ? undefined : contextType);
+	    }
+	    /**
+	     * Find out more information about a particular intent by passing its name, and optionally its context and resultType.
+	     * @param intent Name of the Intent
+	     * @param context Context
+	     * @param resultType The type of result returned for any intent specified during resolution.
+	     *
+	     * @tutorial fdc3.findIntent
+	     */
+	    async findIntent(intent, context, resultType) {
+	        this.wire.sendAction('fdc3-find-intent').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        try {
+	            return await this.client.getInfoForIntent({ name: intent, context, metadata: { resultType } });
+	        }
+	        catch (error) {
+	            const errorToThrow = error.message === utils_1.BROKER_ERRORS.getInfoForIntent ? 'ResolverUnavailable' : error.message;
+	            throw new Error(errorToThrow);
+	        }
+	    }
+	    /**
+	     * Find all the available intents for a particular context.
+	     * @param context
+	     * @param resultType The type of result returned for any intent specified during resolution.
+	     *
+	     * @tutorial fdc3v2.findIntentsByContext
+	     */
+	    async findIntentsByContext(context, resultType) {
+	        this.wire.sendAction('fdc3-find-intents-by-context').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        const payload = resultType ? { context, metadata: { resultType } } : context;
+	        try {
+	            return await InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'fdc3v2FindIntentsByContext', payload);
+	        }
+	        catch (error) {
+	            const errorToThrow = error.message === utils_1.BROKER_ERRORS.getInfoForIntentsByContext ? 'ResolverUnavailable' : error.message;
+	            throw new Error(errorToThrow);
+	        }
+	    }
+	    /**
+	     * Raises a specific intent for resolution against apps registered with the desktop agent.
+	     * @param intent Name of the Intent
+	     * @param context Context associated with the Intent
+	     * @param app
+	     *
+	     * @tutorial fdc3v2.raiseIntent
+	     */
+	    async raiseIntent(intent, context, app) {
+	        this.wire.sendAction('fdc3-raise-intent').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        try {
+	            if (typeof app === 'string') {
+	                console.warn('Passing a string as the app parameter is deprecated, please use an AppIdentifier ({ appId: string; instanceId?: string }).');
+	            }
+	            return (0, utils_2.getIntentResolution)(this.client, context, app, intent);
+	        }
+	        catch (error) {
+	            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fireIntent ? 'ResolverUnavailable' : error.message;
+	            throw new Error(errorToThrow);
+	        }
+	    }
+	    /**
+	     * Finds and raises an intent against apps registered with the desktop agent based purely on the type of the context data.
+	     * @param context Context associated with the Intent
+	     * @param app
+	     *
+	     * @tutorial fdc3v2.raiseIntentForContext
+	     */
+	    async raiseIntentForContext(context, app) {
+	        // TODO: We have to do the same thing we do for raiseIntent here as well.
+	        this.wire.sendAction('fdc3-raise-intent-for-context').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        try {
+	            if (typeof app === 'string') {
+	                console.warn('Passing a string as the app parameter is deprecated, please use an AppIdentifier ({ appId: string; instanceId?: string }).');
+	            }
+	            return (0, utils_2.getIntentResolution)(this.client, context, app);
+	        }
+	        catch (error) {
+	            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fireIntent ? 'ResolverUnavailable' : error.message;
+	            throw new Error(errorToThrow);
+	        }
+	    }
+	    /**
+	     * Adds a listener for incoming intents.
+	     * @param intent  Name of the Intent
+	     * @param handler A callback that handles a context event and may return a promise of a Context or Channel object to be returned to the application that raised the intent.
+	     *
+	     * @tutorial fdc3.addIntentListener
+	     */
+	    async addIntentListener(intent, handler) {
+	        this.wire.sendAction('fdc3-add-intent-listener').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        if (typeof intent !== 'string') {
+	            throw new Error('First argument must be an Intent name');
+	        }
+	        // The FDC3 Intenter handler only expects the context and contextMetadata to be passed to the handler,
+	        // so we wrap it here and only pass those paramaters.
+	        const contextHandler = async (raisedIntent) => {
+	            let intentResult;
+	            let intentResultToSend;
+	            const { context, metadata: intentMetadata } = raisedIntent;
+	            const { contextMetadata, metadata, ...rest } = context;
+	            const intentResolutionResultId = intentMetadata?.intentResolutionResultId || metadata?.intentResolutionResultId;
+	            try {
+	                const newContext = metadata ? { metadata, ...rest } : { ...rest };
+	                intentResult = await handler(newContext, contextMetadata);
+	                intentResultToSend = intentResult;
+	            }
+	            catch (error) {
+	                intentResult = error;
+	                intentResultToSend = { error: true };
+	            }
+	            if (intentResolutionResultId) {
+	                this.fin.InterApplicationBus.publish(intentResolutionResultId, intentResultToSend).catch(() => null);
+	            }
+	            if (intentResult instanceof Error) {
+	                throw new Error(intentResult.message);
+	            }
+	            return intentResult;
+	        };
+	        return this.client.registerIntentHandler(contextHandler, intent, { fdc3Version: '2.0' });
+	    }
+	    /**
+	     * Returns a Channel object for the specified channel, creating it as an App Channel if it does not exist.
+	     * @param channelId
+	     *
+	     * @tutorial fdc3.getOrCreateChannel
+	     */
+	    async getOrCreateChannel(channelId) {
+	        return super.getOrCreateChannel(channelId);
+	    }
+	    /**
+	     * Returns a Channel with an auto-generated identity that is intended for private communication between applications. Primarily used to create channels that will be returned to other applications via an IntentResolution for a raised intent.
+	     *
+	     * @tutorial fdc3v2.createPrivateChannel
+	     */
+	    async createPrivateChannel() {
+	        const channelId = (0, utils_1.generateId)();
+	        await InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'createPrivateChannelProvider', { channelId });
+	        const channelClient = await this.fin.InterApplicationBus.Channel.connect(channelId);
+	        const newPrivateChannelClient = new PrivateChannelClient_1.PrivateChannelClient(channelClient, channelId);
+	        return (0, utils_2.buildPrivateChannelObject)(newPrivateChannelClient);
+	    }
+	    /**
+	     * Retrieves a list of the User Channels available for the app to join.
+	     *
+	     * @tutorial fdc3v2.getUserChannels
+	     */
+	    async getUserChannels() {
+	        const channels = await this.client.getContextGroups();
+	        // fdc3 implementation of getUserChannels returns on array of channels, have to decorate over
+	        // this so people know that these APIs are not supported
+	        return channels.map((channel) => {
+	            // @ts-expect-error TODO [CORE-1524]
+	            return { ...channel, type: 'user', ...(0, utils_2.getUnsupportedChannelApis)('User') };
+	        });
+	    }
+	    /**
+	     * Retrieves a list of the User Channels available for the app to join.
+	     *
+	     * @deprecated Please use {@link fdc3.getUserChannels fdc3.getUserChannels} instead
+	     * @tutorial fdc3.getSystemChannels
+	     */
+	    async getSystemChannels() {
+	        console.warn('This API has been deprecated. Please use fdc3.getUserChannels instead.');
+	        return super.getSystemChannels();
+	    }
+	    /**
+	     * Join an app to a specified User channel.
+	     * @param channelId Channel name
+	     *
+	     * @tutorial fdc3v2.joinUserChannel
+	     */
+	    async joinUserChannel(channelId) {
+	        return super.joinChannel(channelId);
+	    }
+	    /**
+	     * Join an app to a specified User channel.
+	     * @param channelId Channel name
+	     * @deprecated Please use {@link fdc3.joinUserChannel fdc3.joinUserChannel} instead
+	     *
+	     * @tutorial fdc3.joinChannel
+	     */
+	    async joinChannel(channelId) {
+	        console.warn('This API has been deprecated. Please use fdc3.joinUserChannel instead.');
+	        return super.joinChannel(channelId);
+	    }
+	    /**
+	     * Returns the Channel object for the current User channel membership
+	     *
+	     * @tutorial fdc3.getCurrentChannel
+	     */
+	    async getCurrentChannel() {
+	        const currentChannel = await super.getCurrentChannel();
+	        if (!currentChannel) {
+	            return null;
+	        }
+	        return {
+	            ...currentChannel,
+	            type: 'user',
+	            broadcast: this.broadcast.bind(this)
+	        };
+	    }
+	    /**
+	     * Retrieves information about the FDC3 implementation, including the supported version of the FDC3 specification, the name of the provider of the implementation, its own version number, details of whether optional API features are implemented and the metadata of the calling application according to the desktop agent.
+	     * fdc3HandleGetInfo must be overridden in the InteropBroker so that the ImplementationMetadata will have the appMetadata info.
+	     *
+	     * @tutorial fdc3v2.getInfo
+	     */
+	    async getInfo() {
+	        return InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'fdc3v2GetInfo', { fdc3Version: '2.0' });
+	    }
+	}
+	fdc32_0.Fdc3Module2 = Fdc3Module2;
+	return fdc32_0;
+}
+
+var hasRequiredInteropClient;
+
+function requireInteropClient () {
+	if (hasRequiredInteropClient) return InteropClient;
+	hasRequiredInteropClient = 1;
+	var __classPrivateFieldSet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+	    if (kind === "m") throw new TypeError("Private method is not writable");
+	    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+	    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+	    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+	};
+	var __classPrivateFieldGet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+	    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+	    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+	    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+	};
+	var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+	    return (mod && mod.__esModule) ? mod : { "default": mod };
+	};
+	var _InteropClient_clientPromise, _InteropClient_sessionContextGroups;
+	Object.defineProperty(InteropClient, "__esModule", { value: true });
+	InteropClient.InteropClient = void 0;
+	const base_1 = base;
+	const SessionContextGroupClient_1 = __importDefault(SessionContextGroupClient$1);
+	const fdc3_1_2_1 = requireFdc31_2();
+	const fdc3_2_0_1 = requireFdc32_0();
+	const utils_1 = utils$3;
+	/**
+	 * The Interop Client API is broken up into two groups:
+	 *
+	 * **Content Facing APIs** - For Application Developers putting Views into a Platform Window, who care about Context. These are APIs that send out and receive the Context data that flows between applications. Think of this as the Water in the Interop Pipes.
+	 *
+	 * **Context Grouping APIs** - For Platform Developers, to add and remove Views to and from Context Groups. These APIs are utilized under-the-hood in Platforms, so they don't need to be used to participate in Interop. These are the APIs that decide which entities the context data flows between. Think of these as the valves or pipes that control the flow of Context Data for Interop.
+	 *
+	 * ---
+	 *
+	 * All APIs are available at the `fin.me.interop` namespace.
+	 *
+	 * ---
+	 *
+	 * **You only need 2 things to participate in Interop Context Grouping:**
+	 * * A Context Handler for incoming context: {@link InteropClient#addContextHandler addContextHandler(handler, contextType?)}
+	 * * Call setContext on your context group when you want to share context with other group members: {@link InteropClient#setContext setContext(context)}
+	 *
+	 * ---
+	 *
+	 * ##### Constructor
+	 * Returned by {@link Interop.connectSync Interop.connectSync}.
+	 *
+	 * ---
+	 *
+	 * ##### Interop methods intended for Views
+	 *
+	 *
+	 * **Context Groups API**
+	 *  * {@link InteropClient#addContextHandler addContextHandler(handler, contextType?)}
+	 *  * {@link InteropClient#setContext setContext(context)}
+	 *  * {@link InteropClient#getCurrentContext getCurrentContext(contextType?)}
+	 *  * {@link InteropClient#joinSessionContextGroup joinSessionContextGroup(sessionContextGroupId)}
+	 *
+	 *
+	 * **Intents API**
+	 *  * {@link InteropClient#fireIntent fireIntent(intent)}
+	 *  * {@link InteropClient#registerIntentHandler registerIntentHandler(intentHandler, intentName)}
+	 *  * {@link InteropClient#getInfoForIntent getInfoForIntent(infoForIntentOptions)}
+	 *  * {@link InteropClient#getInfoForIntentsByContext getInfoForIntentsByContext(context)}
+	 *  * {@link InteropClient#fireIntentForContext fireIntentForContext(contextForIntent)}
+	 *
+	 * ##### Interop methods intended for Windows
+	 *  * {@link InteropClient#getContextGroups getContextGroups()}
+	 *  * {@link InteropClient#joinContextGroup joinContextGroup(contextGroupId, target?)}
+	 *  * {@link InteropClient#removeFromContextGroup removeFromContextGroup(target?)}
+	 *  * {@link InteropClient#getInfoForContextGroup getInfoForContextGroup(contextGroupId)}
+	 *  * {@link InteropClient#getAllClientsInContextGroup getAllClientsInContextGroup(contextGroupId)}
+	 *
+	 */
+	let InteropClient$1 = class InteropClient extends base_1.Base {
+	    /**
+	     * @internal
+	     */
+	    constructor(wire, clientPromise) {
+	        super(wire);
+	        _InteropClient_clientPromise.set(this, void 0);
+	        _InteropClient_sessionContextGroups.set(this, void 0);
+	        __classPrivateFieldSet(this, _InteropClient_sessionContextGroups, new Map(), "f");
+	        __classPrivateFieldSet(this, _InteropClient_clientPromise, clientPromise, "f");
+	    }
+	    /*
+	    Client APIs
+	    */
+	    /**
+	     * Sets a context for the context group of the current entity.
+	     *
+	     * @remarks The entity must be part of a context group in order set a context.
+	     *
+	     * @param context - New context to set.
+	     *
+	     * @example
+	     * ```js
+	     * setInstrumentContext = async (ticker) => {
+	     *     fin.me.interop.setContext({type: 'instrument', id: {ticker}})
+	     * }
+	     *
+	     * // The user clicks an instrument of interest. We want to set that Instrument context so that the rest of our workflow updates with information for that instrument
+	     * instrumentElement.on('click', (evt) => {
+	     *     setInstrumentContext(evt.ticker)
+	     * })
+	     * ```
+	     */
+	    async setContext(context) {
+	        this.wire.sendAction('interop-client-set-context').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
+	        return client.dispatch('setContext', { context });
+	    }
+	    /**
+	     * Add a context handler for incoming context. If an entity is part of a context group, and then sets its context handler,
+	     * it will receive all of its declared contexts.
+	     *
+	     * @param handler - Handler for incoming context.
+	     * @param contextType - The type of context you wish to handle.
+	     *
+	     * @example
+	     * ```js
+	     * function handleIncomingContext(contextInfo) {
+	     *     const { type, id } = contextInfo;
+	     *     switch (type) {
+	     *         case 'instrument':
+	     *             handleInstrumentContext(contextInfo);
+	     *             break;
+	     *         case 'country':
+	     *             handleCountryContext(contextInfo);
+	     *             break;
+	     *
+	     *         default:
+	     *             break;
+	     *     }
+	     * }
+	     *
+	     *
+	     * function handleInstrumentContext(contextInfo) {
+	     *     const { type, id } = contextInfo;
+	     *     console.log('contextInfo for instrument', contextInfo)
+	     * }
+	     *
+	     * function handleCountryContext(contextInfo) {
+	     *     const { type, id } = contextInfo;
+	     *     console.log('contextInfo for country', contextInfo)
+	     * }
+	     *
+	     * fin.me.interop.addContextHandler(handleIncomingContext);
+	     * ```
+	     *
+	     *
+	     * Passing in a context type as the second parameter will cause the handler to only be invoked with that context type.
+	     *
+	     * ```js
+	     * function handleInstrumentContext(contextInfo) {
+	     *     const { type, id } = contextInfo;
+	     *     console.log('contextInfo for instrument', contextInfo)
+	     * }
+	     *
+	     * function handleCountryContext(contextInfo) {
+	     *     const { type, id } = contextInfo;
+	     *     console.log('contextInfo for country', contextInfo)
+	     * }
+	     *
+	     *
+	     * fin.me.interop.addContextHandler(handleInstrumentContext, 'instrument')
+	     * fin.me.interop.addContextHandler(handleCountryContext, 'country')
+	     * ```
+	     */
+	    async addContextHandler(handler, contextType) {
+	        this.wire.sendAction('interop-client-add-context-handler').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        if (typeof handler !== 'function') {
+	            throw new Error("Non-function argument passed to the first parameter 'handler'. Be aware that the argument order does not match the FDC3 standard.");
+	        }
+	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
+	        let handlerId;
+	        if (contextType) {
+	            handlerId = `invokeContextHandler-${contextType}-${(0, utils_1.generateId)()}`;
+	        }
+	        else {
+	            handlerId = 'invokeContextHandler';
+	        }
+	        const wrappedHandler = (0, utils_1.wrapContextHandler)(handler, handlerId);
+	        client.register(handlerId, wrappedHandler);
+	        await client.dispatch('contextHandlerRegistered', { handlerId, contextType });
+	        return {
+	            unsubscribe: async () => {
+	                client.remove(handlerId);
+	                await client.dispatch('removeContextHandler', { handlerId });
+	            }
+	        };
+	    }
+	    /*
+	    Platform Window APIs
+	    */
+	    /**
+	     * Returns the Interop-Broker-defined context groups available for an entity to join.
+	     * Used by Platform Windows.
+	     *
+	     * @example
+	     * ```js
+	     * fin.me.interop.getContextGroups()
+	     *         .then(contextGroups => {
+	     *             contextGroups.forEach(contextGroup => {
+	     *                 console.log(contextGroup.displayMetadata.name)
+	     *                 console.log(contextGroup.displayMetadata.color)
+	     *             })
+	     *         })
+	     * ```
+	     */
+	    async getContextGroups() {
+	        this.wire.sendAction('interop-client-get-context-groups').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
+	        return client.dispatch('getContextGroups');
+	    }
+	    /**
+	     * Join all Interop Clients at the given identity to context group `contextGroupId`.
+	     * If no target is specified, it adds the sender to the context group.
+	     *
+	     * @remarks Because multiple Channel connections/Interop Clients can potentially exist at a `uuid`/`name` combo, we currently join all Channel connections/Interop Clients at the given identity to the context group.
+	     * If an `endpointId` is provided (which is unlikely, unless the call is coming from an external adapter), then we only join that single connection to the context group.
+	     * For all intents and purposes, there will only be 1 connection present in Platform and Browser implmentations, so this point is more-or-less moot.
+	     * Used by Platform Windows.
+	     *
+	     * @param contextGroupId - Id of the context group.
+	     * @param target - Identity of the entity you wish to join to a context group.
+	     *
+	     * @example
+	     * ```js
+	     * joinViewToContextGroup = async (contextGroupId, view) => {
+	     *     await fin.me.interop.joinContextGroup(contextGroupId, view);
+	     * }
+	     *
+	     * getLastFocusedView()
+	     *     .then(lastFocusedViewIdentity => {
+	     *         joinViewToContextGroup('red', lastFocusedViewIdentity)
+	     *     })
+	     * ```
+	     */
+	    async joinContextGroup(contextGroupId, target) {
+	        this.wire.sendAction('interop-client-join-context-group').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
+	        if (!contextGroupId) {
+	            throw new Error('No contextGroupId specified for joinContextGroup.');
+	        }
+	        return client.dispatch('joinContextGroup', { contextGroupId, target });
+	    }
+	    /**
+	     * Removes the specified target from a context group.
+	     * If no target is specified, it removes the sender from their context group.
+	     * Used by Platform Windows.
+	     *
+	     * @param target - Identity of the entity you wish to join to a context group.
+	     *
+	     * @example
+	     * ```js
+	     * removeViewFromContextGroup = async (view) => {
+	     *     await fin.me.interop.removeFromContextGroup(view);
+	     * }
+	     *
+	     * getLastFocusedView()
+	     *     .then(lastFocusedViewIdentity => {
+	     *         removeViewFromContextGroup(lastFocusedViewIdentity)
+	     *     })
+	     * ```
+	     */
+	    async removeFromContextGroup(target) {
+	        this.wire.sendAction('interop-client-remove-from-context-group').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
+	        return client.dispatch('removeFromContextGroup', { target });
+	    }
+	    /**
+	     * Gets all clients for a context group.
+	     *
+	     * @remarks **This is primarily used for platform windows. Views within a platform should not have to use this API.**
+	     *
+	     * Returns the Interop-Broker-defined context groups available for an entity to join.
+	     * @param contextGroupId - The id of context group you wish to get clients for.
+	     *
+	     * @example
+	     * ```js
+	     * fin.me.interop.getAllClientsInContextGroup('red')
+	     *     .then(clientsInContextGroup => {
+	     *         console.log(clientsInContextGroup)
+	     *     })
+	     * ```
+	     */
+	    async getAllClientsInContextGroup(contextGroupId) {
+	        this.wire.sendAction('interop-client-get-all-clients-in-context-group').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
+	        if (!contextGroupId) {
+	            throw new Error('No contextGroupId specified for getAllClientsInContextGroup.');
+	        }
+	        return client.dispatch('getAllClientsInContextGroup', { contextGroupId });
+	    }
+	    /**
+	     * Gets display info for a context group
+	     *
+	     * @remarks Used by Platform Windows.
+	     * @param contextGroupId - The id of context group you wish to get display info for.
+	     *
+	     * @example
+	     * ```js
+	     * fin.me.interop.getInfoForContextGroup('red')
+	     *     .then(contextGroupInfo => {
+	     *         console.log(contextGroupInfo.displayMetadata.name)
+	     *         console.log(contextGroupInfo.displayMetadata.color)
+	     *     })
+	     * ```
+	     */
+	    async getInfoForContextGroup(contextGroupId) {
+	        this.wire.sendAction('interop-client-get-info-for-context-group').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
+	        if (!contextGroupId) {
+	            throw new Error('No contextGroupId specified for getInfoForContextGroup.');
+	        }
+	        return client.dispatch('getInfoForContextGroup', { contextGroupId });
+	    }
+	    /**
+	     * Sends an intent to the Interop Broker to resolve.
+	     * @param intent - The combination of an action and a context that is passed to an application for resolution.
+	     *
+	     * @example
+	     * ```js
+	     * // View wants to fire an Intent after a user clicks on a ticker
+	     * tickerElement.on('click', (element) => {
+	     *     const ticker = element.innerText;
+	     *     const intent = {
+	     *         name: 'ViewChart',
+	     *         context: {type: 'fdc3.instrument', id: { ticker }}
+	     *     }
+	     *
+	     *     fin.me.interop.fireIntent(intent);
+	     * })
+	     * ```
+	     */
+	    async fireIntent(intent) {
+	        this.wire.sendAction('interop-client-fire-intent').catch((e) => {
+	            // don't expose, this is only for api analytics purposes
+	        });
+	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
+	        return client.dispatch('fireIntent', intent);
+	    }
+	    /**
+	     * Adds an intent handler for incoming intents. The last intent sent of the name subscribed to will be received.
+	     * @param handler - Registered function meant to handle a specific intent type.
+	     * @param intentName - The name of an intent.
+	     *
+	     * @example
+	     * ```js
+	     * const intentHandler = (intent) => {
+	     *     const { context } = intent;
+	     *     myViewChartHandler(context);
+	     * };
+	     *
+	     * const subscription = await fin.me.interop.registerIntentHandler(intentHandler, 'ViewChart');
+	     *
+	     * function myAppCloseSequence() {
+	     *     // to unsubscribe the handler, simply call:
+	     *     subscription.unsubscribe();
+	     * }
+	     * ```
+	     */
+	    async registerIntentHandler(handler, intentName, options) {
+	        this.wire.sendAction('interop-client-register-intent-handler').catch((e) => {
+	            // don't expose, this is only for api analytics purposes
+	        });
+	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
+	        const handlerId = `intent-handler-${intentName}`;
+	        const wrappedHandler = (0, utils_1.wrapIntentHandler)(handler, handlerId);
+	        try {
+	            await client.register(handlerId, wrappedHandler);
+	            await client.dispatch('intentHandlerRegistered', { handlerId, ...options });
+	        }
+	        catch (error) {
+	            throw new Error('Unable to register intent handler');
+	        }
+	        return {
+	            unsubscribe: async () => {
+	                client.remove(handlerId);
+	            }
+	        };
+	    }
+	    /**
+	     * Gets the last context of the Context Group currently subscribed to. It takes an optional Context Type and returns the
+	     * last context of that type.
+	     * @param contextType
+	     *
+	     * @example
+	     * ```js
+	     * await fin.me.interop.joinContextGroup('yellow');
+	     * await fin.me.interop.setContext({ type: 'instrument', id: { ticker: 'FOO' }});
+	     * const currentContext = await fin.me.interop.getCurrentContext();
+	     *
+	     * // with a specific context
+	     * await fin.me.interop.joinContextGroup('yellow');
+	     * await fin.me.interop.setContext({ type: 'country', id: { ISOALPHA3: 'US' }});
+	     * await fin.me.interop.setContext({ type: 'instrument', id: { ticker: 'FOO' }});
+	     * const currentContext = await fin.me.interop.getCurrentContext('country');
+	     * ```
+	     */
+	    async getCurrentContext(contextType) {
+	        this.wire.sendAction('interop-client-get-current-context').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
+	        return client.dispatch('getCurrentContext', { contextType });
+	    }
+	    /**
+	     * Get information for a particular Intent from the Interop Broker.
+	     *
+	     * @remarks To resolve this info, the function handleInfoForIntent is meant to be overridden in the Interop Broker.
+	     * The format for the response will be determined by the App Provider overriding the function.
+	     *
+	     * @param options
+	     *
+	     * @example
+	     * ```js
+	     * const intentInfo = await fin.me.interop.getInfoForIntent('ViewChart');
+	     * ```
+	     */
+	    async getInfoForIntent(options) {
+	        this.wire.sendAction('interop-client-get-info-for-intent').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
+	        return client.dispatch('getInfoForIntent', options);
+	    }
+	    /**
+	     * Get information from the Interop Broker on all Intents that are meant to handle a particular context.
+	     *
+	     * @remarks To resolve this info, the function handleInfoForIntentsByContext is meant to be overridden in the Interop Broker.
+	     * The format for the response will be determined by the App Provider overriding the function.
+	     *
+	     * @param context
+	     *
+	     * @example
+	     * ```js
+	     * tickerElement.on('click', (element) => {
+	     *     const ticker = element.innerText;
+	     *
+	     *     const context = {
+	     *         type: 'fdc3.instrument',
+	     *         id: {
+	     *             ticker
+	     *         }
+	     *     }
+	     *
+	     *     const intentsInfo = await fin.me.interop.getInfoForIntentByContext(context);
+	     * })
+	     * ```
+	     */
+	    async getInfoForIntentsByContext(context) {
+	        this.wire.sendAction('interop-client-get-info-for-intents-by-context').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
+	        return client.dispatch('getInfoForIntentsByContext', context);
+	    }
+	    /**
+	     * Sends a Context that will be resolved to an Intent by the Interop Broker.
+	     * This context accepts a metadata property.
+	     *
+	     * @remarks To resolve this info, the function handleFiredIntentByContext is meant to be overridden in the Interop Broker.
+	     * The format for the response will be determined by the App Provider overriding the function.
+	     *
+	     * @param context
+	     *
+	     * @example
+	     * ```js
+	     * tickerElement.on('click', (element) => {
+	     *     const ticker = element.innerText;
+	     *
+	     *     const context = {
+	     *         type: 'fdc3.instrument',
+	     *         id: {
+	     *             ticker
+	     *         }
+	     *     }
+	     *
+	     *     const intentResolution = await fin.me.interop.fireIntentForContext(context);
+	     * })
+	     * ```
+	     */
+	    async fireIntentForContext(context) {
+	        this.wire.sendAction('interop-client-fire-intent-for-context').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
+	        return client.dispatch('fireIntentForContext', context);
+	    }
+	    /**
+	     * Join the current entity to session context group `sessionContextGroupId` and return a sessionContextGroup instance.
+	     * If the sessionContextGroup doesn't exist, one will get created.
+	     *
+	     * @remarks Session Context Groups do not persist between runs and aren't present on snapshots.
+	     * @param sessionContextGroupId - Id of the context group.
+	     *
+	     * @example
+	     * Say we want to have a Session Context Group that holds UI theme information for all apps to consume:
+	     *
+	     * My color-picker View:
+	     * ```js
+	     *     const themeSessionContextGroup = await fin.me.interop.joinSessionContextGroup('theme');
+	     *
+	     *     const myColorPickerElement = document.getElementById('color-palette-picker');
+	     *     myColorPickerElement.addEventListener('change', event => {
+	     *         themeSessionContextGroup.setContext({ type: 'color-palette', selection: event.value });
+	     *     });
+	     * ```
+	     *
+	     * In other views:
+	     * ```js
+	     *     const themeSessionContextGroup = await fin.me.interop.joinSessionContextGroup('theme');
+	     *
+	     *     const changeColorPalette = ({ selection }) => {
+	     *         // change the color palette to the selection
+	     *     };
+	     *
+	     *     // If the context is already set by the time the handler was set, the handler will get invoked immediately with the current context.
+	     *     themeSessionContextGroup.addContextHandler(changeColorPalette, 'color-palette');
+	     * ```
+	     */
+	    async joinSessionContextGroup(sessionContextGroupId) {
+	        try {
+	            const currentSessionContextGroup = __classPrivateFieldGet(this, _InteropClient_sessionContextGroups, "f").get(sessionContextGroupId);
+	            if (currentSessionContextGroup) {
+	                return currentSessionContextGroup.getUserInstance();
+	            }
+	            const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
+	            const { hasConflict } = await client.dispatch('sessionContextGroup:createIfNeeded', {
+	                sessionContextGroupId
+	            });
+	            if (hasConflict) {
+	                console.warn(`A (non-session) context group with the name "${sessionContextGroupId}" already exists. If you are trying to join a Context Group, call joinContextGroup instead.`);
+	            }
+	            const newSessionContextGroup = new SessionContextGroupClient_1.default(this.wire, __classPrivateFieldGet(this, _InteropClient_clientPromise, "f"), sessionContextGroupId);
+	            __classPrivateFieldGet(this, _InteropClient_sessionContextGroups, "f").set(sessionContextGroupId, newSessionContextGroup);
+	            return newSessionContextGroup.getUserInstance();
+	        }
+	        catch (error) {
+	            console.error(`Error thrown trying to create Session Context Group with id "${sessionContextGroupId}": ${error}`);
+	            throw error;
+	        }
+	    }
+	    /**
+	     * Register a listener that is called when the Interop Client has been disconnected from the Interop Broker.
+	     * Only one listener per Interop Client can be set.
+	     * @param listener
+	     *
+	     * @example
+	     * ```js
+	     * const listener = (event) => {
+	     *     const { type, topic, brokerName} = event;
+	     *     console.log(`Disconnected from Interop Broker ${brokerName} `);
+	     * }
+	     *
+	     * await fin.me.interop.onDisconnection(listener);
+	     * ```
+	     */
+	    async onDisconnection(listener) {
+	        this.wire.sendAction('interop-client-add-ondisconnection-listener').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
+	        return client.onDisconnection((event) => {
+	            const { uuid } = event;
+	            listener({ type: 'interop-broker', topic: 'disconnected', brokerName: uuid });
+	        });
+	    }
+	    getFDC3Sync(version) {
+	        switch (version) {
+	            case '1.2':
+	                return new fdc3_1_2_1.Fdc3Module(() => this, this.wire);
+	            case '2.0':
+	                return new fdc3_2_0_1.Fdc3Module2(() => this, this.wire);
+	            default:
+	                throw new Error(`Invalid FDC3 version provided: ${version}. Must be '1.2' or '2.0'`);
+	        }
+	    }
+	    async getFDC3(version) {
+	        return this.getFDC3Sync(version);
+	    }
+	    /**
+	     * @internal
+	     *
+	     * Used to ferry fdc3-only calls from the fdc3 shim to the Interop Broker
+	     */
+	    static async ferryFdc3Call(interopClient, action, payload) {
+	        const client = await __classPrivateFieldGet(interopClient, _InteropClient_clientPromise, "f");
+	        return client.dispatch(action, payload || null);
+	    }
+	};
+	InteropClient.InteropClient = InteropClient$1;
+	_InteropClient_clientPromise = new WeakMap(), _InteropClient_sessionContextGroups = new WeakMap();
+	return InteropClient;
+}
+
+var overrideCheck = {};
+
+var hasRequiredOverrideCheck;
+
+function requireOverrideCheck () {
+	if (hasRequiredOverrideCheck) return overrideCheck;
+	hasRequiredOverrideCheck = 1;
+	Object.defineProperty(overrideCheck, "__esModule", { value: true });
+	overrideCheck.overrideCheck = overrideCheck.checkFDC32Overrides = overrideCheck.getDefaultViewFdc3VersionFromAppInfo = void 0;
+	const InteropBroker_1 = requireInteropBroker();
+	function getDefaultViewFdc3VersionFromAppInfo({ manifest, initialOptions }) {
+	    const setVersion = manifest?.platform?.defaultViewOptions?.fdc3InteropApi ?? initialOptions.defaultViewOptions?.fdc3InteropApi;
+	    return ['1.2', '2.0'].includes(setVersion ?? '') ? setVersion : undefined;
+	}
+	overrideCheck.getDefaultViewFdc3VersionFromAppInfo = getDefaultViewFdc3VersionFromAppInfo;
+	function checkFDC32Overrides(overriddenBroker) {
+	    // These are the APIs that must be overridden for FDC3 2.0 compliance
+	    const mustOverrideAPIs = [
+	        'fdc3HandleFindInstances',
+	        'handleInfoForIntent',
+	        'handleInfoForIntentsByContext',
+	        'fdc3HandleGetAppMetadata',
+	        'fdc3HandleGetInfo',
+	        'fdc3HandleOpen',
+	        'handleFiredIntent',
+	        'handleFiredIntentForContext'
+	    ];
+	    return mustOverrideAPIs.filter((api) => {
+	        return overriddenBroker[api] === InteropBroker_1.InteropBroker.prototype[api];
+	    });
+	}
+	overrideCheck.checkFDC32Overrides = checkFDC32Overrides;
+	function overrideCheck$1(overriddenBroker, fdc3InteropApi) {
+	    if (fdc3InteropApi && fdc3InteropApi === '2.0') {
+	        const notOverridden = checkFDC32Overrides(overriddenBroker);
+	        if (notOverridden.length > 0) {
+	            console.warn(`WARNING: FDC3 2.0 has been set as a default option for Views in this Platform, but the required InteropBroker APIs for FDC3 2.0 compliance have not all been overridden.\nThe following APIs need to be overridden:\n${notOverridden.join('\n')}`);
+	        }
+	    }
+	}
+	overrideCheck.overrideCheck = overrideCheck$1;
+	return overrideCheck;
+}
+
+var hasRequiredFactory;
+
+function requireFactory () {
+	if (hasRequiredFactory) return Factory$1;
+	hasRequiredFactory = 1;
+	var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+	    return (mod && mod.__esModule) ? mod : { "default": mod };
+	};
+	Object.defineProperty(Factory$1, "__esModule", { value: true });
+	Factory$1.InteropModule = void 0;
+	const cloneDeep_1 = __importDefault(require$$0$1);
+	const inaccessibleObject_1 = inaccessibleObject;
+	const base_1 = base;
+	const InteropBroker_1 = requireInteropBroker();
+	const InteropClient_1 = requireInteropClient();
+	const overrideCheck_1 = requireOverrideCheck();
+	const common_utils_1 = commonUtils;
+	const defaultOverride = (Class) => new Class();
+	const BrokerParamAccessError = 'You have attempted to use or modify InteropBroker parameters, which is not allowed. You are likely using an older InteropBroker override scheme. Please consult our Interop docs for guidance on migrating to the new override scheme.';
+	/**
+	 * Manages creation of Interop Brokers and Interop Clients. These APIs are called under-the-hood in Platforms.
+	 *
+	 */
+	class InteropModule extends base_1.Base {
+	    /**
+	     * Initializes an Interop Broker. This is called under-the-hood for Platforms.
+	     *
+	     * @remarks For Platforms, this is set up automatically. We advise to only create your own Interop Broker
+	     * when not using a Platform app. You can override functions in the Interop Broker. More info {@link InteropBroker here}.
+	     *
+	     * @param name - Name of the Interop Broker.
+	     * @param override - A callback function or array of callback functions that can be used to extend or replace default Interop Broker behavior.
+	     *
+	     * @example
+	     * ``` js
+	     * const interopBroker = await fin.Interop.init('openfin');
+	     * const contextGroups = await interopBroker.getContextGroups();
+	     * console.log(contextGroups);
+	     * ```
+	     */
+	    async init(name, override = defaultOverride) {
+	        this.wire.sendAction('interop-init').catch(() => {
+	            // don't expose, analytics-only call
+	        });
+	        // Allows for manifest-level configuration, without having to override. (e.g. specifying custom context groups)
+	        const options = await this.wire.environment.getInteropInfo(this.wire.getFin());
+	        const objectThatThrows = (0, inaccessibleObject_1.createUnusableObject)(BrokerParamAccessError);
+	        const warningOptsClone = (0, inaccessibleObject_1.createWarningObject)(BrokerParamAccessError, (0, cloneDeep_1.default)(options));
+	        const getProvider = () => {
+	            return this.fin.InterApplicationBus.Channel.create(`interop-broker-${name}`);
+	        };
+	        const throwingGetProvider = async () => {
+	            // eslint-disable-next-line no-console
+	            throw new Error(BrokerParamAccessError);
+	        };
+	        const OverrideableBroker = InteropBroker_1.InteropBroker.createClosedConstructor(this.wire, getProvider, options);
+	        let broker;
+	        if (Array.isArray(override)) {
+	            const BrokerConstructor = (0, common_utils_1.overrideFromComposables)(...override)(OverrideableBroker);
+	            // We need to use these objects because removing them entirely would be a breaking change and we want an informative error
+	            // @ts-expect-error
+	            broker = new BrokerConstructor(objectThatThrows, throwingGetProvider, warningOptsClone);
+	        }
+	        else {
+	            // We need to use these objects because removing them entirely would be a breaking change and we want an informative error
+	            // @ts-expect-error
+	            broker = await override(OverrideableBroker, objectThatThrows, throwingGetProvider, warningOptsClone);
+	        }
+	        (0, overrideCheck_1.overrideCheck)(broker, options.fdc3Version);
+	        return broker;
+	    }
+	    /**
+	     * Connects a client to an Interop broker. This is called under-the-hood for Views in a Platform.
+	     *
+	     * @remarks
+	     * @param name - The name of the Interop Broker to connect to. For Platforms, this will default to the uuid of the Platform.
+	     * @param interopConfig - Information relevant to the Interop Broker. Typically a declaration of
+	     * what context(s) the entity wants to subscribe to, and the current Context Group of the entity.
+	     *
+	     * @example
+	     * ```js
+	     * const interopConfig = {
+	     *     currentContextGroup: 'green'
+	     * }
+	     *
+	     * const interopBroker = await fin.Interop.init('openfin');
+	     * const client = await fin.Interop.connectSync('openfin', interopConfig);
+	     * const contextGroupInfo = await client.getInfoForContextGroup();
+	     * console.log(contextGroupInfo);
+	     * ```
+	     */
+	    connectSync(name, interopConfig) {
+	        this.wire.sendAction('interop-connect-sync').catch(() => {
+	            // don't expose, analytics-only call
+	        });
+	        return new InteropClient_1.InteropClient(this.wire, this.wire.environment.whenReady().then(() => {
+	            return this.fin.InterApplicationBus.Channel.connect(`interop-broker-${name}`, {
+	                payload: interopConfig
+	            });
+	        }));
+	    }
+	}
+	Factory$1.InteropModule = InteropModule;
+	return Factory$1;
+}
+
+var hasRequiredInterop;
+
+function requireInterop () {
+	if (hasRequiredInterop) return interop;
+	hasRequiredInterop = 1;
+	(function (exports) {
+		/**
+		 * Entry point for the OpenFin `Interop` API (`fin.Interop`).
+		 *
+		 * * {@link InteropModule} contains static members of the `Interop` API (available under `fin.Interop`)
+		 * * {@link InteropClient} and {@link InteropBroker} document instances of their respective classes.
+		 *
+		 * @packageDocumentation
+		 */
+		var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    var desc = Object.getOwnPropertyDescriptor(m, k);
+		    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+		      desc = { enumerable: true, get: function() { return m[k]; } };
+		    }
+		    Object.defineProperty(o, k2, desc);
+		}) : (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    o[k2] = m[k];
+		}));
+		var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+		    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+		};
+		Object.defineProperty(exports, "__esModule", { value: true });
+		__exportStar(requireFactory(), exports);
+		__exportStar(requireInteropClient(), exports);
+		__exportStar(requireInteropBroker(), exports); 
+	} (interop));
+	return interop;
+}
+
+var snapshotSource = {};
+
+var Factory = {};
+
+var Instance = {};
+
+var utils = {};
+
+Object.defineProperty(utils, "__esModule", { value: true });
+utils.getSnapshotSourceChannelName = void 0;
+const channelPrefix = 'snapshot-source-provider-';
+const getSnapshotSourceChannelName = (id) => `${channelPrefix}${id.uuid}`;
+utils.getSnapshotSourceChannelName = getSnapshotSourceChannelName;
+
+var __classPrivateFieldSet$1 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet$1 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _SnapshotSource_identity, _SnapshotSource_getConnection, _SnapshotSource_getClient, _SnapshotSource_startConnection, _SnapshotSource_setUpConnectionListener;
+Object.defineProperty(Instance, "__esModule", { value: true });
+Instance.SnapshotSource = void 0;
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+const base_1$1 = base;
+const utils_1$1 = utils;
+const connectionMap = new Map();
+/**
+ * Enables configuring a SnapshotSource with custom getSnapshot and applySnapshot methods.
+ *
+ * @typeParam Snapshot Implementation-defined shape of an application snapshot.  Allows
+ * custom snapshot implementations for legacy applications to define their own snapshot format.
+ */
+class SnapshotSource extends base_1$1.Base {
+    /**
+     * @internal
+     */
+    constructor(wire, id) {
+        super(wire);
+        _SnapshotSource_identity.set(this, void 0);
+        _SnapshotSource_getConnection.set(this, () => {
+            if (!connectionMap.has(this.identity.uuid)) {
+                connectionMap.set(this.identity.uuid, { eventFired: null, clientPromise: null });
+            }
+            return connectionMap.get(this.identity.uuid);
+        });
+        _SnapshotSource_getClient.set(this, () => {
+            if (!__classPrivateFieldGet$1(this, _SnapshotSource_getConnection, "f").call(this).clientPromise) {
+                __classPrivateFieldGet$1(this, _SnapshotSource_getConnection, "f").call(this).clientPromise = __classPrivateFieldGet$1(this, _SnapshotSource_startConnection, "f").call(this);
+            }
+            return __classPrivateFieldGet$1(this, _SnapshotSource_getConnection, "f").call(this).clientPromise;
+        });
+        _SnapshotSource_startConnection.set(this, async () => {
+            const channelName = (0, utils_1$1.getSnapshotSourceChannelName)(this.identity);
+            try {
+                if (!__classPrivateFieldGet$1(this, _SnapshotSource_getConnection, "f").call(this).eventFired) {
+                    await __classPrivateFieldGet$1(this, _SnapshotSource_setUpConnectionListener, "f").call(this);
+                }
+                const client = await this.fin.InterApplicationBus.Channel.connect(channelName, { wait: false });
+                client.onDisconnection(() => {
+                    __classPrivateFieldGet$1(this, _SnapshotSource_getConnection, "f").call(this).clientPromise = null;
+                    __classPrivateFieldGet$1(this, _SnapshotSource_getConnection, "f").call(this).eventFired = null;
+                });
+                return client;
+            }
+            catch (e) {
+                __classPrivateFieldGet$1(this, _SnapshotSource_getConnection, "f").call(this).clientPromise = null;
+                throw new Error("The targeted SnapshotSource is not currently initialized. Await this object's ready() method.");
+            }
+        });
+        _SnapshotSource_setUpConnectionListener.set(this, async () => {
+            const channelName = (0, utils_1$1.getSnapshotSourceChannelName)(this.identity);
+            let resolve;
+            let reject;
+            const eventFired = new Promise((y, n) => {
+                resolve = y;
+                reject = n;
+            });
+            __classPrivateFieldGet$1(this, _SnapshotSource_getConnection, "f").call(this).eventFired = eventFired;
+            const listener = async (e) => {
+                try {
+                    if (e.channelName === channelName) {
+                        resolve();
+                        await this.fin.InterApplicationBus.Channel.removeListener('connected', listener);
+                    }
+                }
+                catch (err) {
+                    reject(err);
+                }
+            };
+            await this.fin.InterApplicationBus.Channel.on('connected', listener);
+        });
+        __classPrivateFieldSet$1(this, _SnapshotSource_identity, id, "f");
+    }
+    get identity() {
+        return __classPrivateFieldGet$1(this, _SnapshotSource_identity, "f");
+    }
+    /**
+     * Method to determine if the SnapshotSource has been initialized.
+     *
+     * @remarks Use when the parent application is starting up to ensure the SnapshotSource is able to accept and
+     * apply a snapshot using the {@link SnapshotSource#applySnapshot applySnapshot} method.
+     *
+     * @example
+     * ```js
+     * let snapshotSource = fin.SnapshotSource.wrapSync(fin.me);
+     *
+     * const snapshotProvider = {
+     *     async getSnapshot() { return 'foo' },
+     *     async applySnapshot(snapshot) {
+     *       console.log(snapshot);
+     *       return undefined;
+     *     }
+     * }
+     * await fin.SnapshotSource.init(snapshotProvider);
+     *
+     * try {
+     *   await snapshotSource.ready();
+     *   await snapshotSource.applySnapshot('foo');
+     * } catch (err) {
+     *   console.log(err)
+     * }
+     * ```
+     */
+    async ready() {
+        this.wire.sendAction('snapshot-source-ready').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        // eslint-disable-next-line no-async-promise-executor
+        try {
+            // If getClient was already called before this, do we have a timing issue where the channel might have been created but we missed the event but this still fails?
+            await __classPrivateFieldGet$1(this, _SnapshotSource_getClient, "f").call(this);
+        }
+        catch (e) {
+            // it was not running.
+            await __classPrivateFieldGet$1(this, _SnapshotSource_getConnection, "f").call(this).eventFired;
+        }
+    }
+    /**
+     * Call the SnapshotSource's getSnapshot method defined by {@link SnapshotSource.SnapshotSourceModule#init init}.
+     *
+     */
+    async getSnapshot() {
+        this.wire.sendAction('snapshot-source-get-snapshot').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const client = await __classPrivateFieldGet$1(this, _SnapshotSource_getClient, "f").call(this);
+        const response = (await client.dispatch('get-snapshot'));
+        return (await response).snapshot;
+    }
+    /**
+     * Call the SnapshotSource's applySnapshot method defined by {@link SnapshotSource.SnapshotSourceModule#init init}.
+     *
+     */
+    async applySnapshot(snapshot) {
+        this.wire.sendAction('snapshot-source-apply-snapshot').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        const client = await __classPrivateFieldGet$1(this, _SnapshotSource_getClient, "f").call(this);
+        return client.dispatch('apply-snapshot', { snapshot });
+    }
+}
+Instance.SnapshotSource = SnapshotSource;
+_SnapshotSource_identity = new WeakMap(), _SnapshotSource_getConnection = new WeakMap(), _SnapshotSource_getClient = new WeakMap(), _SnapshotSource_startConnection = new WeakMap(), _SnapshotSource_setUpConnectionListener = new WeakMap();
+
+Object.defineProperty(Factory, "__esModule", { value: true });
+Factory.SnapshotSourceModule = void 0;
+const base_1 = base;
+const Instance_1 = Instance;
+const utils_1 = utils;
+/**
+ * Static namespace for OpenFin API methods that interact with the {@link SnapshotSource} class, available under `fin.SnapshotSource`.
+ */
+class SnapshotSourceModule extends base_1.Base {
+    /**
+     * Initializes a SnapshotSource with the getSnapshot and applySnapshot methods defined.
+     *
+     * @typeParam Snapshot Implementation-defined shape of an application snapshot.  Allows
+     * custom snapshot implementations for legacy applications to define their own snapshot format.
+     *
+     * @example
+     * ```js
+     * const snapshotProvider = {
+     *     async getSnapshot() {
+     *       const bounds = await fin.me.getBounds();
+     *       return bounds;
+     *      },
+     *     async applySnapshot(snapshot) {
+     *       await fin.me.setBounds(snapshot);
+     *       return undefined;
+     *     }
+     * }
+     *
+     * await fin.SnapshotSource.init(snapshotProvider);
+     * ```
+     *
+     */
+    async init(provider) {
+        this.wire.sendAction('snapshot-source-init').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        if (typeof provider !== 'object' ||
+            typeof provider.getSnapshot !== 'function' ||
+            typeof provider.applySnapshot !== 'function') {
+            throw new Error('you must pass in a valid SnapshotProvider');
+        }
+        const channel = await this.fin.InterApplicationBus.Channel.create((0, utils_1.getSnapshotSourceChannelName)(this.fin.me));
+        channel.register('get-snapshot', async () => {
+            const snapshot = await provider.getSnapshot();
+            return { snapshot };
+        });
+        channel.register('apply-snapshot', ({ snapshot }) => provider.applySnapshot(snapshot));
+    }
+    /**
+     * Synchronously returns a SnapshotSource object that represents the current SnapshotSource.
+     *
+     * @example
+     * ```js
+     * const snapshotSource = fin.SnapshotSource.wrapSync(fin.me);
+     * // Use wrapped instance's getSnapshot method, e.g.:
+     * const snapshot = await snapshotSource.getSnapshot();
+     * ```
+     */
+    wrapSync(identity) {
+        this.wire.sendAction('snapshot-source-wrap-sync').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        return new Instance_1.SnapshotSource(this.wire, identity);
+    }
+    /**
+     * Asynchronously returns a SnapshotSource object that represents the current SnapshotSource.
+     *
+     * @example
+     * ```js
+     * const snapshotSource = await fin.SnapshotSource.wrap(fin.me);
+     * // Use wrapped instance's getSnapshot method, e.g.:
+     * const snapshot = await snapshotSource.getSnapshot();
+     * ```
+     */
+    async wrap(identity) {
+        this.wire.sendAction('snapshot-source-wrap').catch((e) => {
+            // don't expose, analytics-only call
+        });
+        return this.wrapSync(identity);
+    }
+}
+Factory.SnapshotSourceModule = SnapshotSourceModule;
+
+(function (exports) {
+	/**
+	 * Entry points for the OpenFin `SnapshotSource` API (`fin.SnapshotSource`).
+	 *
+	 * * {@link SnapshotSourceModule} contains static members of the `SnapshotSource` API, accessible through `fin.SnapshotSource`.
+	 * * {@link SnapshotSource} describes an instance of an OpenFin SnapshotSource, e.g. as returned by `fin.SnapshotSource.wrap`.
+	 *
+	 * These are separate code entities, and are documented separately.  In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/32.114.76.10/index.html),
+	 * both of these were documented on the same page.
+	 *
+	 * @packageDocumentation
+	 */
+	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    var desc = Object.getOwnPropertyDescriptor(m, k);
+	    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+	      desc = { enumerable: true, get: function() { return m[k]; } };
+	    }
+	    Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    o[k2] = m[k];
+	}));
+	var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	__exportStar(Factory, exports);
+	__exportStar(Instance, exports); 
+} (snapshotSource));
+
+Object.defineProperty(fin$2, "__esModule", { value: true });
+var Fin_1 = fin$2.Fin = void 0;
+const events_1$3 = require$$0;
+// Import from the file rather than the directory in case someone consuming types is using module resolution other than "node"
+const index_1 = system;
+const index_2 = requireWindow();
+const index_3 = requireApplication();
+const index_4 = interappbus;
+const index_5 = clipboard;
+const index_6 = externalApplication;
+const index_7 = frame;
+const index_8 = globalHotkey;
+const index_9 = requireView();
+const index_10 = platform;
+const me_1$2 = me;
+const interop_1 = requireInterop();
+const snapshot_source_1 = snapshotSource;
+/**
+ * @internal
+ */
+class Fin extends events_1$3.EventEmitter {
+    /**
+     * @internal
+     */
+    constructor(wire) {
+        super();
+        this.wire = wire;
+        this.System = new index_1.System(wire);
+        this.Window = new index_2._WindowModule(wire);
+        this.Application = new index_3.ApplicationModule(wire);
+        this.InterApplicationBus = new index_4.InterApplicationBus(wire);
+        this.Clipboard = new index_5.Clipboard(wire);
+        this.ExternalApplication = new index_6.ExternalApplicationModule(wire);
+        this.Frame = new index_7._FrameModule(wire);
+        this.GlobalHotkey = new index_8.GlobalHotkey(wire);
+        this.Platform = new index_10.PlatformModule(wire, this.InterApplicationBus.Channel);
+        this.View = new index_9.ViewModule(wire);
+        this.Interop = new interop_1.InteropModule(wire);
+        this.SnapshotSource = new snapshot_source_1.SnapshotSourceModule(wire);
+        wire.registerFin(this);
+        this.me = (0, me_1$2.getMe)(wire);
+        // Handle disconnect events
+        wire.on('disconnected', () => {
+            this.emit('disconnected');
+        });
+    }
+}
+Fin_1 = fin$2.Fin = Fin;
+
+var transport = {};
+
+var wire = {};
+
+Object.defineProperty(wire, "__esModule", { value: true });
+wire.isInternalConnectConfig = wire.isPortDiscoveryConfig = wire.isNewConnectConfig = wire.isConfigWithReceiver = wire.isRemoteConfig = wire.isExistingConnectConfig = wire.isExternalConfig = void 0;
+function isExternalConfig(config) {
+    if (typeof config.manifestUrl === 'string') {
+        return true;
+    }
+    return false;
+}
+wire.isExternalConfig = isExternalConfig;
+function isExistingConnectConfig(config) {
+    return hasUuid(config) && typeof config.address === 'string';
+}
+wire.isExistingConnectConfig = isExistingConnectConfig;
+function isRemoteConfig(config) {
+    return isExistingConnectConfig(config) && typeof config.token === 'string';
+}
+wire.isRemoteConfig = isRemoteConfig;
+function isConfigWithReceiver(config) {
+    return typeof config.receiver === 'object' && isRemoteConfig({ ...config, address: '' });
+}
+wire.isConfigWithReceiver = isConfigWithReceiver;
+function hasUuid(config) {
+    return typeof config.uuid === 'string';
+}
+function hasRuntimeVersion(config) {
+    return config.runtime && typeof config.runtime.version === 'string';
+}
+function isNewConnectConfig(config) {
+    return hasUuid(config) && hasRuntimeVersion(config);
+}
+wire.isNewConnectConfig = isNewConnectConfig;
+function isPortDiscoveryConfig(config) {
+    return (isExternalConfig(config) && hasRuntimeVersion(config)) || isNewConnectConfig(config);
+}
+wire.isPortDiscoveryConfig = isPortDiscoveryConfig;
+function isInternalConnectConfig(config) {
+    return isExistingConnectConfig(config) || isNewConnectConfig(config);
+}
+wire.isInternalConnectConfig = isInternalConnectConfig;
+
+var eventAggregator = {};
+
+var emitterMap = {};
+
+Object.defineProperty(emitterMap, "__esModule", { value: true });
+emitterMap.EmitterMap = void 0;
+const events_1$2 = require$$0;
+class EmitterMap {
+    constructor() {
+        this.storage = new Map();
+    }
+    // eslint-disable-next-line class-methods-use-this
+    hashKeys(keys) {
+        const hashed = keys.map(normalizeString);
+        return hashed.join('/');
+    }
+    getOrCreate(keys) {
+        const hash = this.hashKeys(keys);
+        if (!this.storage.has(hash)) {
+            this.storage.set(hash, new events_1$2.EventEmitter());
+        }
+        // We set it above
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return this.storage.get(hash);
+    }
+    has(keys) {
+        return this.storage.has(this.hashKeys(keys));
+    }
+    delete(keys) {
+        const hash = this.hashKeys(keys);
+        return this.storage.delete(hash);
+    }
+}
+emitterMap.EmitterMap = EmitterMap;
+function normalizeString(s) {
+    const b = Buffer.from(s);
+    return b.toString('base64');
+}
+
+Object.defineProperty(eventAggregator, "__esModule", { value: true });
+const emitterMap_1 = emitterMap;
+function isEventMessage(message) {
+    return message.action === 'process-desktop-event';
+}
+function mapKeyFromEvent(event) {
+    const { topic } = event;
+    if (topic === 'frame' || topic === 'window' || topic === 'view') {
+        const { uuid, name } = event;
+        return [topic, uuid, name];
+    }
+    if (topic === 'application') {
+        const { uuid } = event;
+        return [topic, uuid];
+    }
+    return [topic];
+}
+class EventAggregator extends emitterMap_1.EmitterMap {
+    constructor() {
+        super(...arguments);
+        this.dispatchEvent = (message) => {
+            if (isEventMessage(message)) {
+                const { payload } = message;
+                const accessor = mapKeyFromEvent(payload);
+                if (this.has(accessor)) {
+                    this.getOrCreate(accessor).emit(payload.type, payload);
+                    return true;
+                }
+            }
+            return false;
+        };
+    }
+}
+eventAggregator.default = EventAggregator;
+
+var __classPrivateFieldSet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _Transport_wire, _Transport_fin;
+Object.defineProperty(transport, "__esModule", { value: true });
+var Transport_1 = transport.Transport = void 0;
+const events_1$1 = require$$0;
+const wire_1 = wire;
+const transport_errors_1 = transportErrors;
+const eventAggregator_1 = __importDefault(eventAggregator);
+const me_1$1 = me;
+const errors_1 = errors;
+class Transport extends events_1$1.EventEmitter {
+    constructor(WireType, environment, config) {
+        super();
+        this.wireListeners = new Map();
+        this.topicRefMap = new Map();
+        this.eventAggregator = new eventAggregator_1.default();
+        this.messageHandlers = [this.eventAggregator.dispatchEvent];
+        _Transport_wire.set(this, void 0);
+        // Typing as unknown to avoid circular dependency, should not be used directly.
+        _Transport_fin.set(this, void 0);
+        this.connectSync = () => {
+            const wire = __classPrivateFieldGet(this, _Transport_wire, "f");
+            wire.connectSync();
+        };
+        // This function is only used in our tests.
+        this.getPort = () => {
+            const wire = __classPrivateFieldGet(this, _Transport_wire, "f");
+            return wire.getPort();
+        };
+        __classPrivateFieldSet(this, _Transport_wire, new WireType(this.onmessage.bind(this)), "f");
+        this.environment = environment;
+        this.sendRaw = __classPrivateFieldGet(this, _Transport_wire, "f").send.bind(__classPrivateFieldGet(this, _Transport_wire, "f"));
+        this.registerMessageHandler(this.handleMessage.bind(this));
+        __classPrivateFieldGet(this, _Transport_wire, "f").on('disconnected', () => {
+            for (const [, { handleNack }] of this.wireListeners) {
+                handleNack({ reason: 'Remote connection has closed' });
+            }
+            this.wireListeners.clear();
+            this.emit('disconnected');
+        });
+        const { uuid, name } = config;
+        const entityType = this.environment.getCurrentEntityType();
+        this.me = (0, me_1$1.getBaseMe)(entityType, uuid, name);
+    }
+    getFin() {
+        if (!__classPrivateFieldGet(this, _Transport_fin, "f")) {
+            throw new Error('No Fin object registered for this transport');
+        }
+        return __classPrivateFieldGet(this, _Transport_fin, "f");
+    }
+    registerFin(_fin) {
+        if (__classPrivateFieldGet(this, _Transport_fin, "f")) {
+            throw new Error('Fin object has already been registered for this transport');
+        }
+        __classPrivateFieldSet(this, _Transport_fin, _fin, "f");
+    }
+    shutdown() {
+        const wire = __classPrivateFieldGet(this, _Transport_wire, "f");
+        return wire.shutdown();
+    }
+    async connect(config) {
+        if ((0, wire_1.isConfigWithReceiver)(config)) {
+            await __classPrivateFieldGet(this, _Transport_wire, "f").connect(config.receiver);
+            return this.authorize(config);
+        }
+        if ((0, wire_1.isRemoteConfig)(config)) {
+            return this.connectRemote(config);
+        }
+        if ((0, wire_1.isExistingConnectConfig)(config)) {
+            return this.connectByPort(config);
+        }
+        if ((0, wire_1.isNewConnectConfig)(config)) {
+            const port = await this.environment.retrievePort(config);
+            return this.connectByPort({ ...config, address: `ws://localhost:${port}` });
+        }
+        return undefined;
+    }
+    async connectRemote(config) {
+        await __classPrivateFieldGet(this, _Transport_wire, "f").connect(new (this.environment.getWsConstructor())(config.address));
+        return this.authorize(config);
+    }
+    async connectByPort(config) {
+        const { address, uuid } = config;
+        const reqAuthPayload = { ...config, type: 'file-token' };
+        const wire = __classPrivateFieldGet(this, _Transport_wire, "f");
+        await wire.connect(new (this.environment.getWsConstructor())(config.address));
+        const requestExtAuthRet = await this.sendAction('request-external-authorization', {
+            uuid,
+            type: 'file-token'
+        }, true);
+        if (requestExtAuthRet.action !== 'external-authorization-response') {
+            throw new transport_errors_1.UnexpectedActionError(requestExtAuthRet.action);
+        }
+        await this.environment.writeToken(requestExtAuthRet.payload.file, requestExtAuthRet.payload.token);
+        return this.authorize(reqAuthPayload);
+    }
+    async authorize(reqAuthPayload) {
+        const requestAuthRet = await this.sendAction('request-authorization', reqAuthPayload, true);
+        if (requestAuthRet.action !== 'authorization-response') {
+            throw new transport_errors_1.UnexpectedActionError(requestAuthRet.action);
+        }
+        else if (requestAuthRet.payload.success !== true) {
+            throw new transport_errors_1.RuntimeError(requestAuthRet.payload);
+        }
+    }
+    sendAction(action, payload = {}, uncorrelated = false
+    // specialResponse type is only used for 'requestAuthorization'
+    ) {
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        let cancel = () => { };
+        // We want the callsite from the caller of this function, not from here.
+        const callSites = transport_errors_1.RuntimeError.getCallSite(1);
+        const messageId = this.environment.getNextMessageId();
+        const prom = new Promise((resolve, reject) => {
+            cancel = reject;
+            const msg = {
+                action,
+                payload,
+                messageId
+            };
+            const wire = __classPrivateFieldGet(this, _Transport_wire, "f");
+            this.addWireListener(messageId, resolve, (payload) => this.nackHandler(payload, reject, callSites), uncorrelated);
+            return wire.send(msg).catch(reject);
+        });
+        return Object.assign(prom, { cancel, messageId });
+    }
+    nackHandler(payloadOrMessage, reject, callSites) {
+        if (typeof payloadOrMessage === 'string') {
+            // NOTE: this is for backwards compatibility to support plain string rejections
+            reject(payloadOrMessage);
+        }
+        else {
+            reject(new transport_errors_1.RuntimeError(payloadOrMessage, callSites));
+        }
+    }
+    ferryAction(origData) {
+        return new Promise((resolve, reject) => {
+            const id = this.environment.getNextMessageId();
+            origData.messageId = id;
+            const resolver = (data) => {
+                resolve(data.payload);
+            };
+            const wire = __classPrivateFieldGet(this, _Transport_wire, "f");
+            return wire
+                .send(origData)
+                .then(() => this.addWireListener(id, resolver, (payload) => this.nackHandler(payload, reject), false))
+                .catch(reject);
+        });
+    }
+    registerMessageHandler(handler) {
+        this.messageHandlers.push(handler);
+    }
+    addWireListener(id, resolve, handleNack, uncorrelated) {
+        if (uncorrelated) {
+            this.uncorrelatedListener = resolve;
+        }
+        else if (this.wireListeners.has(id)) {
+            handleNack({
+                reason: 'Duplicate handler id',
+                error: (0, errors_1.errorToPOJO)(new transport_errors_1.DuplicateCorrelationError(String(id)))
+            });
+        }
+        else {
+            this.wireListeners.set(id, { resolve, handleNack });
+        }
+        // Timeout and reject()?
+    }
+    // This method executes message handlers until the _one_ that handles the message (returns truthy) has run
+    onmessage(data) {
+        for (const h of this.messageHandlers) {
+            h.call(null, data);
+        }
+    }
+    handleMessage(data) {
+        const id = data.correlationId || NaN;
+        if (!('correlationId' in data)) {
+            if (this.uncorrelatedListener) {
+                this.uncorrelatedListener.call(null, data);
+            }
+            this.uncorrelatedListener = () => {
+                // empty block
+            };
+        }
+        else if (!this.wireListeners.has(id)) {
+            return false;
+        }
+        else {
+            // We just checked for existence above
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const { resolve, handleNack } = this.wireListeners.get(id);
+            if (data.action !== 'ack') {
+                handleNack({ reason: 'Did not receive ack action', error: (0, errors_1.errorToPOJO)(new transport_errors_1.NoAckError(data.action)) });
+            }
+            else if (!('payload' in data)) {
+                // I'm not sure when this code would actually run, but passing in something that doeesn't have a reason to the runtimeerror constructor will not end well.
+                // @ts-expect-error
+                if (typeof data.reason === 'string') {
+                    handleNack(data);
+                }
+                else {
+                    console.warn('Received invalid response from core', data);
+                    handleNack({ reason: 'invalid response shape' });
+                }
+            }
+            else if (!data.payload.success) {
+                handleNack(data.payload);
+            }
+            else {
+                resolve.call(null, data);
+            }
+            this.wireListeners.delete(id);
+        }
+        return true;
+    }
+}
+Transport_1 = transport.Transport = Transport;
+_Transport_wire = new WeakMap(), _Transport_fin = new WeakMap();
+
+var mockEnvironment = {};
+
+Object.defineProperty(mockEnvironment, "__esModule", { value: true });
+var MockEnvironment_1 = mockEnvironment.MockEnvironment = void 0;
+const me_1 = me;
+class MockEnvironment {
+    constructor() {
+        this.type = 'other';
+        this.childViews = true;
+    }
+    getAdapterVersionSync() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    async getInteropInfo() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getDefaultChannelOptions() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getRtcPeer() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    layoutAllowedInContext(_fin) {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    initLayoutManager() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    applyLayoutSnapshot() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    async createLayout() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    async destroyLayout() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    async resolveLayout() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    initPlatform() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    observeBounds() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    writeToken(path, token) {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    retrievePort(config) {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getNextMessageId() {
+        return `mock-message-id-${Math.random()}`;
+    }
+    getRandomId() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    createChildContent(options) {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getWebWindow(identity) {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getCurrentEntityIdentity() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getCurrentEntityType() {
+        return 'unknown';
+    }
+    raiseEvent(eventName, eventArgs) {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getUrl() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    whenReady() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getWsConstructor() {
+        throw new Error('Method not implemented.');
+    }
+}
+MockEnvironment_1 = mockEnvironment.MockEnvironment = MockEnvironment;
+
+var mockWire = {};
+
+Object.defineProperty(mockWire, "__esModule", { value: true });
+var MockWire_1 = mockWire.MockWire = void 0;
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const events_1 = require$$0;
+class MockWire extends events_1.EventEmitter {
+    connect() {
+        throw new Error('You are not running in OpenFin.');
+    }
+    connectSync() {
+        throw new Error('You are not running in OpenFin.');
+    }
+    send(data) {
+        throw new Error('You are not running in OpenFin.');
+    }
+    shutdown() {
+        throw new Error('You are not running in OpenFin.');
+    }
+    getPort() {
+        throw new Error('This transport has no port');
+    }
+    // eslint-disable-next-line no-useless-constructor
+    constructor() {
+        super();
+    }
+}
+MockWire_1 = mockWire.MockWire = MockWire;
+
+const fin$1 = ((typeof window !== 'undefined' && window?.fin) ||
+    (() => {
+        const environment = new MockEnvironment_1();
+        const transport = new Transport_1(MockWire_1, environment, {
+            uuid: '',
+            name: ''
+        });
+        return new Fin_1(transport);
+    })());
+
+exports.OpenFin = OpenFin$1;
+exports["default"] = OpenFin$1;
+exports.fin = fin$1;
+
+
+/***/ }),
+
+/***/ "../../node_modules/events/events.js":
+/*!*******************************************!*\
+  !*** ../../node_modules/events/events.js ***!
+  \*******************************************/
+/***/ ((module) => {
+
+"use strict";
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+
+var R = typeof Reflect === 'object' ? Reflect : null
+var ReflectApply = R && typeof R.apply === 'function'
+  ? R.apply
+  : function ReflectApply(target, receiver, args) {
+    return Function.prototype.apply.call(target, receiver, args);
+  }
+
+var ReflectOwnKeys
+if (R && typeof R.ownKeys === 'function') {
+  ReflectOwnKeys = R.ownKeys
+} else if (Object.getOwnPropertySymbols) {
+  ReflectOwnKeys = function ReflectOwnKeys(target) {
+    return Object.getOwnPropertyNames(target)
+      .concat(Object.getOwnPropertySymbols(target));
+  };
+} else {
+  ReflectOwnKeys = function ReflectOwnKeys(target) {
+    return Object.getOwnPropertyNames(target);
+  };
+}
+
+function ProcessEmitWarning(warning) {
+  if (console && console.warn) console.warn(warning);
+}
+
+var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
+  return value !== value;
+}
+
+function EventEmitter() {
+  EventEmitter.init.call(this);
+}
+module.exports = EventEmitter;
+module.exports.once = once;
+
+// Backwards-compat with node 0.10.x
+EventEmitter.EventEmitter = EventEmitter;
+
+EventEmitter.prototype._events = undefined;
+EventEmitter.prototype._eventsCount = 0;
+EventEmitter.prototype._maxListeners = undefined;
+
+// By default EventEmitters will print a warning if more than 10 listeners are
+// added to it. This is a useful default which helps finding memory leaks.
+var defaultMaxListeners = 10;
+
+function checkListener(listener) {
+  if (typeof listener !== 'function') {
+    throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+  }
+}
+
+Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
+  enumerable: true,
+  get: function() {
+    return defaultMaxListeners;
+  },
+  set: function(arg) {
+    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
+      throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
+    }
+    defaultMaxListeners = arg;
+  }
+});
+
+EventEmitter.init = function() {
+
+  if (this._events === undefined ||
+      this._events === Object.getPrototypeOf(this)._events) {
+    this._events = Object.create(null);
+    this._eventsCount = 0;
+  }
+
+  this._maxListeners = this._maxListeners || undefined;
+};
+
+// Obviously not all Emitters should be limited to 10. This function allows
+// that to be increased. Set to zero for unlimited.
+EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
+  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
+    throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
+  }
+  this._maxListeners = n;
+  return this;
+};
+
+function _getMaxListeners(that) {
+  if (that._maxListeners === undefined)
+    return EventEmitter.defaultMaxListeners;
+  return that._maxListeners;
+}
+
+EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
+  return _getMaxListeners(this);
+};
+
+EventEmitter.prototype.emit = function emit(type) {
+  var args = [];
+  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
+  var doError = (type === 'error');
+
+  var events = this._events;
+  if (events !== undefined)
+    doError = (doError && events.error === undefined);
+  else if (!doError)
+    return false;
+
+  // If there is no 'error' event listener then throw.
+  if (doError) {
+    var er;
+    if (args.length > 0)
+      er = args[0];
+    if (er instanceof Error) {
+      // Note: The comments on the `throw` lines are intentional, they show
+      // up in Node's output if this results in an unhandled exception.
+      throw er; // Unhandled 'error' event
+    }
+    // At least give some kind of context to the user
+    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));
+    err.context = er;
+    throw err; // Unhandled 'error' event
+  }
+
+  var handler = events[type];
+
+  if (handler === undefined)
+    return false;
+
+  if (typeof handler === 'function') {
+    ReflectApply(handler, this, args);
+  } else {
+    var len = handler.length;
+    var listeners = arrayClone(handler, len);
+    for (var i = 0; i < len; ++i)
+      ReflectApply(listeners[i], this, args);
+  }
+
+  return true;
+};
+
+function _addListener(target, type, listener, prepend) {
+  var m;
+  var events;
+  var existing;
+
+  checkListener(listener);
+
+  events = target._events;
+  if (events === undefined) {
+    events = target._events = Object.create(null);
+    target._eventsCount = 0;
+  } else {
+    // To avoid recursion in the case that type === "newListener"! Before
+    // adding it to the listeners, first emit "newListener".
+    if (events.newListener !== undefined) {
+      target.emit('newListener', type,
+                  listener.listener ? listener.listener : listener);
+
+      // Re-assign `events` because a newListener handler could have caused the
+      // this._events to be assigned to a new object
+      events = target._events;
+    }
+    existing = events[type];
+  }
+
+  if (existing === undefined) {
+    // Optimize the case of one listener. Don't need the extra array object.
+    existing = events[type] = listener;
+    ++target._eventsCount;
+  } else {
+    if (typeof existing === 'function') {
+      // Adding the second element, need to change to array.
+      existing = events[type] =
+        prepend ? [listener, existing] : [existing, listener];
+      // If we've already got an array, just append.
+    } else if (prepend) {
+      existing.unshift(listener);
+    } else {
+      existing.push(listener);
+    }
+
+    // Check for listener leak
+    m = _getMaxListeners(target);
+    if (m > 0 && existing.length > m && !existing.warned) {
+      existing.warned = true;
+      // No error code for this since it is a Warning
+      // eslint-disable-next-line no-restricted-syntax
+      var w = new Error('Possible EventEmitter memory leak detected. ' +
+                          existing.length + ' ' + String(type) + ' listeners ' +
+                          'added. Use emitter.setMaxListeners() to ' +
+                          'increase limit');
+      w.name = 'MaxListenersExceededWarning';
+      w.emitter = target;
+      w.type = type;
+      w.count = existing.length;
+      ProcessEmitWarning(w);
+    }
+  }
+
+  return target;
+}
+
+EventEmitter.prototype.addListener = function addListener(type, listener) {
+  return _addListener(this, type, listener, false);
+};
+
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+
+EventEmitter.prototype.prependListener =
+    function prependListener(type, listener) {
+      return _addListener(this, type, listener, true);
+    };
+
+function onceWrapper() {
+  if (!this.fired) {
+    this.target.removeListener(this.type, this.wrapFn);
+    this.fired = true;
+    if (arguments.length === 0)
+      return this.listener.call(this.target);
+    return this.listener.apply(this.target, arguments);
+  }
+}
+
+function _onceWrap(target, type, listener) {
+  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
+  var wrapped = onceWrapper.bind(state);
+  wrapped.listener = listener;
+  state.wrapFn = wrapped;
+  return wrapped;
+}
+
+EventEmitter.prototype.once = function once(type, listener) {
+  checkListener(listener);
+  this.on(type, _onceWrap(this, type, listener));
+  return this;
+};
+
+EventEmitter.prototype.prependOnceListener =
+    function prependOnceListener(type, listener) {
+      checkListener(listener);
+      this.prependListener(type, _onceWrap(this, type, listener));
+      return this;
+    };
+
+// Emits a 'removeListener' event if and only if the listener was removed.
+EventEmitter.prototype.removeListener =
+    function removeListener(type, listener) {
+      var list, events, position, i, originalListener;
+
+      checkListener(listener);
+
+      events = this._events;
+      if (events === undefined)
+        return this;
+
+      list = events[type];
+      if (list === undefined)
+        return this;
+
+      if (list === listener || list.listener === listener) {
+        if (--this._eventsCount === 0)
+          this._events = Object.create(null);
+        else {
+          delete events[type];
+          if (events.removeListener)
+            this.emit('removeListener', type, list.listener || listener);
+        }
+      } else if (typeof list !== 'function') {
+        position = -1;
+
+        for (i = list.length - 1; i >= 0; i--) {
+          if (list[i] === listener || list[i].listener === listener) {
+            originalListener = list[i].listener;
+            position = i;
+            break;
+          }
+        }
+
+        if (position < 0)
+          return this;
+
+        if (position === 0)
+          list.shift();
+        else {
+          spliceOne(list, position);
+        }
+
+        if (list.length === 1)
+          events[type] = list[0];
+
+        if (events.removeListener !== undefined)
+          this.emit('removeListener', type, originalListener || listener);
+      }
+
+      return this;
+    };
+
+EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+
+EventEmitter.prototype.removeAllListeners =
+    function removeAllListeners(type) {
+      var listeners, events, i;
+
+      events = this._events;
+      if (events === undefined)
+        return this;
+
+      // not listening for removeListener, no need to emit
+      if (events.removeListener === undefined) {
+        if (arguments.length === 0) {
+          this._events = Object.create(null);
+          this._eventsCount = 0;
+        } else if (events[type] !== undefined) {
+          if (--this._eventsCount === 0)
+            this._events = Object.create(null);
+          else
+            delete events[type];
+        }
+        return this;
+      }
+
+      // emit removeListener for all listeners on all events
+      if (arguments.length === 0) {
+        var keys = Object.keys(events);
+        var key;
+        for (i = 0; i < keys.length; ++i) {
+          key = keys[i];
+          if (key === 'removeListener') continue;
+          this.removeAllListeners(key);
+        }
+        this.removeAllListeners('removeListener');
+        this._events = Object.create(null);
+        this._eventsCount = 0;
+        return this;
+      }
+
+      listeners = events[type];
+
+      if (typeof listeners === 'function') {
+        this.removeListener(type, listeners);
+      } else if (listeners !== undefined) {
+        // LIFO order
+        for (i = listeners.length - 1; i >= 0; i--) {
+          this.removeListener(type, listeners[i]);
+        }
+      }
+
+      return this;
+    };
+
+function _listeners(target, type, unwrap) {
+  var events = target._events;
+
+  if (events === undefined)
+    return [];
+
+  var evlistener = events[type];
+  if (evlistener === undefined)
+    return [];
+
+  if (typeof evlistener === 'function')
+    return unwrap ? [evlistener.listener || evlistener] : [evlistener];
+
+  return unwrap ?
+    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+}
+
+EventEmitter.prototype.listeners = function listeners(type) {
+  return _listeners(this, type, true);
+};
+
+EventEmitter.prototype.rawListeners = function rawListeners(type) {
+  return _listeners(this, type, false);
+};
+
+EventEmitter.listenerCount = function(emitter, type) {
+  if (typeof emitter.listenerCount === 'function') {
+    return emitter.listenerCount(type);
+  } else {
+    return listenerCount.call(emitter, type);
+  }
+};
+
+EventEmitter.prototype.listenerCount = listenerCount;
+function listenerCount(type) {
+  var events = this._events;
+
+  if (events !== undefined) {
+    var evlistener = events[type];
+
+    if (typeof evlistener === 'function') {
+      return 1;
+    } else if (evlistener !== undefined) {
+      return evlistener.length;
+    }
+  }
+
+  return 0;
+}
+
+EventEmitter.prototype.eventNames = function eventNames() {
+  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
+};
+
+function arrayClone(arr, n) {
+  var copy = new Array(n);
+  for (var i = 0; i < n; ++i)
+    copy[i] = arr[i];
+  return copy;
+}
+
+function spliceOne(list, index) {
+  for (; index + 1 < list.length; index++)
+    list[index] = list[index + 1];
+  list.pop();
+}
+
+function unwrapListeners(arr) {
+  var ret = new Array(arr.length);
+  for (var i = 0; i < ret.length; ++i) {
+    ret[i] = arr[i].listener || arr[i];
+  }
+  return ret;
+}
+
+function once(emitter, name) {
+  return new Promise(function (resolve, reject) {
+    function errorListener(err) {
+      emitter.removeListener(name, resolver);
+      reject(err);
+    }
+
+    function resolver() {
+      if (typeof emitter.removeListener === 'function') {
+        emitter.removeListener('error', errorListener);
+      }
+      resolve([].slice.call(arguments));
+    };
+
+    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
+    if (name !== 'error') {
+      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
+    }
+  });
+}
+
+function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
+  if (typeof emitter.on === 'function') {
+    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);
+  }
+}
+
+function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
+  if (typeof emitter.on === 'function') {
+    if (flags.once) {
+      emitter.once(name, listener);
+    } else {
+      emitter.on(name, listener);
+    }
+  } else if (typeof emitter.addEventListener === 'function') {
+    // EventTarget does not have `error` event semantics like Node
+    // EventEmitters, we do not listen for `error` events here.
+    emitter.addEventListener(name, function wrapListener(arg) {
+      // IE does not have builtin `{ once: true }` support so we
+      // have to do it manually.
+      if (flags.once) {
+        emitter.removeEventListener(name, wrapListener);
+      }
+      listener(arg);
+    });
+  } else {
+    throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
+  }
+}
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_DataView.js":
+/*!**********************************************!*\
+  !*** ../../node_modules/lodash/_DataView.js ***!
+  \**********************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var getNative = __webpack_require__(/*! ./_getNative */ "../../node_modules/lodash/_getNative.js"),
+    root = __webpack_require__(/*! ./_root */ "../../node_modules/lodash/_root.js");
+
+/* Built-in method references that are verified to be native. */
+var DataView = getNative(root, 'DataView');
+
+module.exports = DataView;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_Hash.js":
+/*!******************************************!*\
+  !*** ../../node_modules/lodash/_Hash.js ***!
+  \******************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var hashClear = __webpack_require__(/*! ./_hashClear */ "../../node_modules/lodash/_hashClear.js"),
+    hashDelete = __webpack_require__(/*! ./_hashDelete */ "../../node_modules/lodash/_hashDelete.js"),
+    hashGet = __webpack_require__(/*! ./_hashGet */ "../../node_modules/lodash/_hashGet.js"),
+    hashHas = __webpack_require__(/*! ./_hashHas */ "../../node_modules/lodash/_hashHas.js"),
+    hashSet = __webpack_require__(/*! ./_hashSet */ "../../node_modules/lodash/_hashSet.js");
+
+/**
+ * Creates a hash object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function Hash(entries) {
+  var index = -1,
+      length = entries == null ? 0 : entries.length;
+
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+
+// Add methods to `Hash`.
+Hash.prototype.clear = hashClear;
+Hash.prototype['delete'] = hashDelete;
+Hash.prototype.get = hashGet;
+Hash.prototype.has = hashHas;
+Hash.prototype.set = hashSet;
+
+module.exports = Hash;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_ListCache.js":
+/*!***********************************************!*\
+  !*** ../../node_modules/lodash/_ListCache.js ***!
+  \***********************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var listCacheClear = __webpack_require__(/*! ./_listCacheClear */ "../../node_modules/lodash/_listCacheClear.js"),
+    listCacheDelete = __webpack_require__(/*! ./_listCacheDelete */ "../../node_modules/lodash/_listCacheDelete.js"),
+    listCacheGet = __webpack_require__(/*! ./_listCacheGet */ "../../node_modules/lodash/_listCacheGet.js"),
+    listCacheHas = __webpack_require__(/*! ./_listCacheHas */ "../../node_modules/lodash/_listCacheHas.js"),
+    listCacheSet = __webpack_require__(/*! ./_listCacheSet */ "../../node_modules/lodash/_listCacheSet.js");
+
+/**
+ * Creates an list cache object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function ListCache(entries) {
+  var index = -1,
+      length = entries == null ? 0 : entries.length;
+
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+
+// Add methods to `ListCache`.
+ListCache.prototype.clear = listCacheClear;
+ListCache.prototype['delete'] = listCacheDelete;
+ListCache.prototype.get = listCacheGet;
+ListCache.prototype.has = listCacheHas;
+ListCache.prototype.set = listCacheSet;
+
+module.exports = ListCache;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_Map.js":
+/*!*****************************************!*\
+  !*** ../../node_modules/lodash/_Map.js ***!
+  \*****************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var getNative = __webpack_require__(/*! ./_getNative */ "../../node_modules/lodash/_getNative.js"),
+    root = __webpack_require__(/*! ./_root */ "../../node_modules/lodash/_root.js");
+
+/* Built-in method references that are verified to be native. */
+var Map = getNative(root, 'Map');
+
+module.exports = Map;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_MapCache.js":
+/*!**********************************************!*\
+  !*** ../../node_modules/lodash/_MapCache.js ***!
+  \**********************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var mapCacheClear = __webpack_require__(/*! ./_mapCacheClear */ "../../node_modules/lodash/_mapCacheClear.js"),
+    mapCacheDelete = __webpack_require__(/*! ./_mapCacheDelete */ "../../node_modules/lodash/_mapCacheDelete.js"),
+    mapCacheGet = __webpack_require__(/*! ./_mapCacheGet */ "../../node_modules/lodash/_mapCacheGet.js"),
+    mapCacheHas = __webpack_require__(/*! ./_mapCacheHas */ "../../node_modules/lodash/_mapCacheHas.js"),
+    mapCacheSet = __webpack_require__(/*! ./_mapCacheSet */ "../../node_modules/lodash/_mapCacheSet.js");
+
+/**
+ * Creates a map cache object to store key-value pairs.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function MapCache(entries) {
+  var index = -1,
+      length = entries == null ? 0 : entries.length;
+
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+
+// Add methods to `MapCache`.
+MapCache.prototype.clear = mapCacheClear;
+MapCache.prototype['delete'] = mapCacheDelete;
+MapCache.prototype.get = mapCacheGet;
+MapCache.prototype.has = mapCacheHas;
+MapCache.prototype.set = mapCacheSet;
+
+module.exports = MapCache;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_Promise.js":
+/*!*********************************************!*\
+  !*** ../../node_modules/lodash/_Promise.js ***!
+  \*********************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var getNative = __webpack_require__(/*! ./_getNative */ "../../node_modules/lodash/_getNative.js"),
+    root = __webpack_require__(/*! ./_root */ "../../node_modules/lodash/_root.js");
+
+/* Built-in method references that are verified to be native. */
+var Promise = getNative(root, 'Promise');
+
+module.exports = Promise;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_Set.js":
+/*!*****************************************!*\
+  !*** ../../node_modules/lodash/_Set.js ***!
+  \*****************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var getNative = __webpack_require__(/*! ./_getNative */ "../../node_modules/lodash/_getNative.js"),
+    root = __webpack_require__(/*! ./_root */ "../../node_modules/lodash/_root.js");
+
+/* Built-in method references that are verified to be native. */
+var Set = getNative(root, 'Set');
+
+module.exports = Set;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_SetCache.js":
+/*!**********************************************!*\
+  !*** ../../node_modules/lodash/_SetCache.js ***!
+  \**********************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var MapCache = __webpack_require__(/*! ./_MapCache */ "../../node_modules/lodash/_MapCache.js"),
+    setCacheAdd = __webpack_require__(/*! ./_setCacheAdd */ "../../node_modules/lodash/_setCacheAdd.js"),
+    setCacheHas = __webpack_require__(/*! ./_setCacheHas */ "../../node_modules/lodash/_setCacheHas.js");
+
+/**
+ *
+ * Creates an array cache object to store unique values.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [values] The values to cache.
+ */
+function SetCache(values) {
+  var index = -1,
+      length = values == null ? 0 : values.length;
+
+  this.__data__ = new MapCache;
+  while (++index < length) {
+    this.add(values[index]);
+  }
+}
+
+// Add methods to `SetCache`.
+SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+SetCache.prototype.has = setCacheHas;
+
+module.exports = SetCache;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_Stack.js":
+/*!*******************************************!*\
+  !*** ../../node_modules/lodash/_Stack.js ***!
+  \*******************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var ListCache = __webpack_require__(/*! ./_ListCache */ "../../node_modules/lodash/_ListCache.js"),
+    stackClear = __webpack_require__(/*! ./_stackClear */ "../../node_modules/lodash/_stackClear.js"),
+    stackDelete = __webpack_require__(/*! ./_stackDelete */ "../../node_modules/lodash/_stackDelete.js"),
+    stackGet = __webpack_require__(/*! ./_stackGet */ "../../node_modules/lodash/_stackGet.js"),
+    stackHas = __webpack_require__(/*! ./_stackHas */ "../../node_modules/lodash/_stackHas.js"),
+    stackSet = __webpack_require__(/*! ./_stackSet */ "../../node_modules/lodash/_stackSet.js");
+
+/**
+ * Creates a stack cache object to store key-value pairs.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function Stack(entries) {
+  var data = this.__data__ = new ListCache(entries);
+  this.size = data.size;
+}
+
+// Add methods to `Stack`.
+Stack.prototype.clear = stackClear;
+Stack.prototype['delete'] = stackDelete;
+Stack.prototype.get = stackGet;
+Stack.prototype.has = stackHas;
+Stack.prototype.set = stackSet;
+
+module.exports = Stack;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_Symbol.js":
+/*!********************************************!*\
+  !*** ../../node_modules/lodash/_Symbol.js ***!
+  \********************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var root = __webpack_require__(/*! ./_root */ "../../node_modules/lodash/_root.js");
+
+/** Built-in value references. */
+var Symbol = root.Symbol;
+
+module.exports = Symbol;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_Uint8Array.js":
+/*!************************************************!*\
+  !*** ../../node_modules/lodash/_Uint8Array.js ***!
+  \************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var root = __webpack_require__(/*! ./_root */ "../../node_modules/lodash/_root.js");
+
+/** Built-in value references. */
+var Uint8Array = root.Uint8Array;
+
+module.exports = Uint8Array;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_WeakMap.js":
+/*!*********************************************!*\
+  !*** ../../node_modules/lodash/_WeakMap.js ***!
+  \*********************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var getNative = __webpack_require__(/*! ./_getNative */ "../../node_modules/lodash/_getNative.js"),
+    root = __webpack_require__(/*! ./_root */ "../../node_modules/lodash/_root.js");
+
+/* Built-in method references that are verified to be native. */
+var WeakMap = getNative(root, 'WeakMap');
+
+module.exports = WeakMap;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_arrayEach.js":
+/*!***********************************************!*\
+  !*** ../../node_modules/lodash/_arrayEach.js ***!
+  \***********************************************/
+/***/ ((module) => {
+
+/**
+ * A specialized version of `_.forEach` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns `array`.
+ */
+function arrayEach(array, iteratee) {
+  var index = -1,
+      length = array == null ? 0 : array.length;
+
+  while (++index < length) {
+    if (iteratee(array[index], index, array) === false) {
+      break;
+    }
+  }
+  return array;
+}
+
+module.exports = arrayEach;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_arrayFilter.js":
+/*!*************************************************!*\
+  !*** ../../node_modules/lodash/_arrayFilter.js ***!
+  \*************************************************/
+/***/ ((module) => {
+
+/**
+ * A specialized version of `_.filter` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {Array} Returns the new filtered array.
+ */
+function arrayFilter(array, predicate) {
+  var index = -1,
+      length = array == null ? 0 : array.length,
+      resIndex = 0,
+      result = [];
+
+  while (++index < length) {
+    var value = array[index];
+    if (predicate(value, index, array)) {
+      result[resIndex++] = value;
+    }
+  }
+  return result;
+}
+
+module.exports = arrayFilter;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_arrayLikeKeys.js":
+/*!***************************************************!*\
+  !*** ../../node_modules/lodash/_arrayLikeKeys.js ***!
+  \***************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var baseTimes = __webpack_require__(/*! ./_baseTimes */ "../../node_modules/lodash/_baseTimes.js"),
+    isArguments = __webpack_require__(/*! ./isArguments */ "../../node_modules/lodash/isArguments.js"),
+    isArray = __webpack_require__(/*! ./isArray */ "../../node_modules/lodash/isArray.js"),
+    isBuffer = __webpack_require__(/*! ./isBuffer */ "../../node_modules/lodash/isBuffer.js"),
+    isIndex = __webpack_require__(/*! ./_isIndex */ "../../node_modules/lodash/_isIndex.js"),
+    isTypedArray = __webpack_require__(/*! ./isTypedArray */ "../../node_modules/lodash/isTypedArray.js");
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Creates an array of the enumerable property names of the array-like `value`.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @param {boolean} inherited Specify returning inherited property names.
+ * @returns {Array} Returns the array of property names.
+ */
+function arrayLikeKeys(value, inherited) {
+  var isArr = isArray(value),
+      isArg = !isArr && isArguments(value),
+      isBuff = !isArr && !isArg && isBuffer(value),
+      isType = !isArr && !isArg && !isBuff && isTypedArray(value),
+      skipIndexes = isArr || isArg || isBuff || isType,
+      result = skipIndexes ? baseTimes(value.length, String) : [],
+      length = result.length;
+
+  for (var key in value) {
+    if ((inherited || hasOwnProperty.call(value, key)) &&
+        !(skipIndexes && (
+           // Safari 9 has enumerable `arguments.length` in strict mode.
+           key == 'length' ||
+           // Node.js 0.10 has enumerable non-index properties on buffers.
+           (isBuff && (key == 'offset' || key == 'parent')) ||
+           // PhantomJS 2 has enumerable non-index properties on typed arrays.
+           (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
+           // Skip index properties.
+           isIndex(key, length)
+        ))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+
+module.exports = arrayLikeKeys;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_arrayPush.js":
+/*!***********************************************!*\
+  !*** ../../node_modules/lodash/_arrayPush.js ***!
+  \***********************************************/
+/***/ ((module) => {
+
+/**
+ * Appends the elements of `values` to `array`.
+ *
+ * @private
+ * @param {Array} array The array to modify.
+ * @param {Array} values The values to append.
+ * @returns {Array} Returns `array`.
+ */
+function arrayPush(array, values) {
+  var index = -1,
+      length = values.length,
+      offset = array.length;
+
+  while (++index < length) {
+    array[offset + index] = values[index];
+  }
+  return array;
+}
+
+module.exports = arrayPush;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_arraySome.js":
+/*!***********************************************!*\
+  !*** ../../node_modules/lodash/_arraySome.js ***!
+  \***********************************************/
+/***/ ((module) => {
+
+/**
+ * A specialized version of `_.some` for arrays without support for iteratee
+ * shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {boolean} Returns `true` if any element passes the predicate check,
+ *  else `false`.
+ */
+function arraySome(array, predicate) {
+  var index = -1,
+      length = array == null ? 0 : array.length;
+
+  while (++index < length) {
+    if (predicate(array[index], index, array)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+module.exports = arraySome;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_assignValue.js":
+/*!*************************************************!*\
+  !*** ../../node_modules/lodash/_assignValue.js ***!
+  \*************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var baseAssignValue = __webpack_require__(/*! ./_baseAssignValue */ "../../node_modules/lodash/_baseAssignValue.js"),
+    eq = __webpack_require__(/*! ./eq */ "../../node_modules/lodash/eq.js");
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Assigns `value` to `key` of `object` if the existing value is not equivalent
+ * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * for equality comparisons.
+ *
+ * @private
+ * @param {Object} object The object to modify.
+ * @param {string} key The key of the property to assign.
+ * @param {*} value The value to assign.
+ */
+function assignValue(object, key, value) {
+  var objValue = object[key];
+  if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
+      (value === undefined && !(key in object))) {
+    baseAssignValue(object, key, value);
+  }
+}
+
+module.exports = assignValue;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_assocIndexOf.js":
+/*!**************************************************!*\
+  !*** ../../node_modules/lodash/_assocIndexOf.js ***!
+  \**************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var eq = __webpack_require__(/*! ./eq */ "../../node_modules/lodash/eq.js");
+
+/**
+ * Gets the index at which the `key` is found in `array` of key-value pairs.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {*} key The key to search for.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+function assocIndexOf(array, key) {
+  var length = array.length;
+  while (length--) {
+    if (eq(array[length][0], key)) {
+      return length;
+    }
+  }
+  return -1;
+}
+
+module.exports = assocIndexOf;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_baseAssign.js":
+/*!************************************************!*\
+  !*** ../../node_modules/lodash/_baseAssign.js ***!
+  \************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var copyObject = __webpack_require__(/*! ./_copyObject */ "../../node_modules/lodash/_copyObject.js"),
+    keys = __webpack_require__(/*! ./keys */ "../../node_modules/lodash/keys.js");
+
+/**
+ * The base implementation of `_.assign` without support for multiple sources
+ * or `customizer` functions.
+ *
+ * @private
+ * @param {Object} object The destination object.
+ * @param {Object} source The source object.
+ * @returns {Object} Returns `object`.
+ */
+function baseAssign(object, source) {
+  return object && copyObject(source, keys(source), object);
+}
+
+module.exports = baseAssign;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_baseAssignIn.js":
+/*!**************************************************!*\
+  !*** ../../node_modules/lodash/_baseAssignIn.js ***!
+  \**************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var copyObject = __webpack_require__(/*! ./_copyObject */ "../../node_modules/lodash/_copyObject.js"),
+    keysIn = __webpack_require__(/*! ./keysIn */ "../../node_modules/lodash/keysIn.js");
+
+/**
+ * The base implementation of `_.assignIn` without support for multiple sources
+ * or `customizer` functions.
+ *
+ * @private
+ * @param {Object} object The destination object.
+ * @param {Object} source The source object.
+ * @returns {Object} Returns `object`.
+ */
+function baseAssignIn(object, source) {
+  return object && copyObject(source, keysIn(source), object);
+}
+
+module.exports = baseAssignIn;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_baseAssignValue.js":
+/*!*****************************************************!*\
+  !*** ../../node_modules/lodash/_baseAssignValue.js ***!
+  \*****************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var defineProperty = __webpack_require__(/*! ./_defineProperty */ "../../node_modules/lodash/_defineProperty.js");
+
+/**
+ * The base implementation of `assignValue` and `assignMergeValue` without
+ * value checks.
+ *
+ * @private
+ * @param {Object} object The object to modify.
+ * @param {string} key The key of the property to assign.
+ * @param {*} value The value to assign.
+ */
+function baseAssignValue(object, key, value) {
+  if (key == '__proto__' && defineProperty) {
+    defineProperty(object, key, {
+      'configurable': true,
+      'enumerable': true,
+      'value': value,
+      'writable': true
+    });
+  } else {
+    object[key] = value;
+  }
+}
+
+module.exports = baseAssignValue;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_baseClone.js":
+/*!***********************************************!*\
+  !*** ../../node_modules/lodash/_baseClone.js ***!
+  \***********************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var Stack = __webpack_require__(/*! ./_Stack */ "../../node_modules/lodash/_Stack.js"),
+    arrayEach = __webpack_require__(/*! ./_arrayEach */ "../../node_modules/lodash/_arrayEach.js"),
+    assignValue = __webpack_require__(/*! ./_assignValue */ "../../node_modules/lodash/_assignValue.js"),
+    baseAssign = __webpack_require__(/*! ./_baseAssign */ "../../node_modules/lodash/_baseAssign.js"),
+    baseAssignIn = __webpack_require__(/*! ./_baseAssignIn */ "../../node_modules/lodash/_baseAssignIn.js"),
+    cloneBuffer = __webpack_require__(/*! ./_cloneBuffer */ "../../node_modules/lodash/_cloneBuffer.js"),
+    copyArray = __webpack_require__(/*! ./_copyArray */ "../../node_modules/lodash/_copyArray.js"),
+    copySymbols = __webpack_require__(/*! ./_copySymbols */ "../../node_modules/lodash/_copySymbols.js"),
+    copySymbolsIn = __webpack_require__(/*! ./_copySymbolsIn */ "../../node_modules/lodash/_copySymbolsIn.js"),
+    getAllKeys = __webpack_require__(/*! ./_getAllKeys */ "../../node_modules/lodash/_getAllKeys.js"),
+    getAllKeysIn = __webpack_require__(/*! ./_getAllKeysIn */ "../../node_modules/lodash/_getAllKeysIn.js"),
+    getTag = __webpack_require__(/*! ./_getTag */ "../../node_modules/lodash/_getTag.js"),
+    initCloneArray = __webpack_require__(/*! ./_initCloneArray */ "../../node_modules/lodash/_initCloneArray.js"),
+    initCloneByTag = __webpack_require__(/*! ./_initCloneByTag */ "../../node_modules/lodash/_initCloneByTag.js"),
+    initCloneObject = __webpack_require__(/*! ./_initCloneObject */ "../../node_modules/lodash/_initCloneObject.js"),
+    isArray = __webpack_require__(/*! ./isArray */ "../../node_modules/lodash/isArray.js"),
+    isBuffer = __webpack_require__(/*! ./isBuffer */ "../../node_modules/lodash/isBuffer.js"),
+    isMap = __webpack_require__(/*! ./isMap */ "../../node_modules/lodash/isMap.js"),
+    isObject = __webpack_require__(/*! ./isObject */ "../../node_modules/lodash/isObject.js"),
+    isSet = __webpack_require__(/*! ./isSet */ "../../node_modules/lodash/isSet.js"),
+    keys = __webpack_require__(/*! ./keys */ "../../node_modules/lodash/keys.js"),
+    keysIn = __webpack_require__(/*! ./keysIn */ "../../node_modules/lodash/keysIn.js");
+
+/** Used to compose bitmasks for cloning. */
+var CLONE_DEEP_FLAG = 1,
+    CLONE_FLAT_FLAG = 2,
+    CLONE_SYMBOLS_FLAG = 4;
+
+/** `Object#toString` result references. */
+var argsTag = '[object Arguments]',
+    arrayTag = '[object Array]',
+    boolTag = '[object Boolean]',
+    dateTag = '[object Date]',
+    errorTag = '[object Error]',
+    funcTag = '[object Function]',
+    genTag = '[object GeneratorFunction]',
+    mapTag = '[object Map]',
+    numberTag = '[object Number]',
+    objectTag = '[object Object]',
+    regexpTag = '[object RegExp]',
+    setTag = '[object Set]',
+    stringTag = '[object String]',
+    symbolTag = '[object Symbol]',
+    weakMapTag = '[object WeakMap]';
+
+var arrayBufferTag = '[object ArrayBuffer]',
+    dataViewTag = '[object DataView]',
+    float32Tag = '[object Float32Array]',
+    float64Tag = '[object Float64Array]',
+    int8Tag = '[object Int8Array]',
+    int16Tag = '[object Int16Array]',
+    int32Tag = '[object Int32Array]',
+    uint8Tag = '[object Uint8Array]',
+    uint8ClampedTag = '[object Uint8ClampedArray]',
+    uint16Tag = '[object Uint16Array]',
+    uint32Tag = '[object Uint32Array]';
+
+/** Used to identify `toStringTag` values supported by `_.clone`. */
+var cloneableTags = {};
+cloneableTags[argsTag] = cloneableTags[arrayTag] =
+cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =
+cloneableTags[boolTag] = cloneableTags[dateTag] =
+cloneableTags[float32Tag] = cloneableTags[float64Tag] =
+cloneableTags[int8Tag] = cloneableTags[int16Tag] =
+cloneableTags[int32Tag] = cloneableTags[mapTag] =
+cloneableTags[numberTag] = cloneableTags[objectTag] =
+cloneableTags[regexpTag] = cloneableTags[setTag] =
+cloneableTags[stringTag] = cloneableTags[symbolTag] =
+cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =
+cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
+cloneableTags[errorTag] = cloneableTags[funcTag] =
+cloneableTags[weakMapTag] = false;
+
+/**
+ * The base implementation of `_.clone` and `_.cloneDeep` which tracks
+ * traversed objects.
+ *
+ * @private
+ * @param {*} value The value to clone.
+ * @param {boolean} bitmask The bitmask flags.
+ *  1 - Deep clone
+ *  2 - Flatten inherited properties
+ *  4 - Clone symbols
+ * @param {Function} [customizer] The function to customize cloning.
+ * @param {string} [key] The key of `value`.
+ * @param {Object} [object] The parent object of `value`.
+ * @param {Object} [stack] Tracks traversed objects and their clone counterparts.
+ * @returns {*} Returns the cloned value.
+ */
+function baseClone(value, bitmask, customizer, key, object, stack) {
+  var result,
+      isDeep = bitmask & CLONE_DEEP_FLAG,
+      isFlat = bitmask & CLONE_FLAT_FLAG,
+      isFull = bitmask & CLONE_SYMBOLS_FLAG;
+
+  if (customizer) {
+    result = object ? customizer(value, key, object, stack) : customizer(value);
+  }
+  if (result !== undefined) {
+    return result;
+  }
+  if (!isObject(value)) {
+    return value;
+  }
+  var isArr = isArray(value);
+  if (isArr) {
+    result = initCloneArray(value);
+    if (!isDeep) {
+      return copyArray(value, result);
+    }
+  } else {
+    var tag = getTag(value),
+        isFunc = tag == funcTag || tag == genTag;
+
+    if (isBuffer(value)) {
+      return cloneBuffer(value, isDeep);
+    }
+    if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
+      result = (isFlat || isFunc) ? {} : initCloneObject(value);
+      if (!isDeep) {
+        return isFlat
+          ? copySymbolsIn(value, baseAssignIn(result, value))
+          : copySymbols(value, baseAssign(result, value));
+      }
+    } else {
+      if (!cloneableTags[tag]) {
+        return object ? value : {};
+      }
+      result = initCloneByTag(value, tag, isDeep);
+    }
+  }
+  // Check for circular references and return its corresponding clone.
+  stack || (stack = new Stack);
+  var stacked = stack.get(value);
+  if (stacked) {
+    return stacked;
+  }
+  stack.set(value, result);
+
+  if (isSet(value)) {
+    value.forEach(function(subValue) {
+      result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
+    });
+  } else if (isMap(value)) {
+    value.forEach(function(subValue, key) {
+      result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));
+    });
+  }
+
+  var keysFunc = isFull
+    ? (isFlat ? getAllKeysIn : getAllKeys)
+    : (isFlat ? keysIn : keys);
+
+  var props = isArr ? undefined : keysFunc(value);
+  arrayEach(props || value, function(subValue, key) {
+    if (props) {
+      key = subValue;
+      subValue = value[key];
+    }
+    // Recursively populate clone (susceptible to call stack limits).
+    assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));
+  });
+  return result;
+}
+
+module.exports = baseClone;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_baseCreate.js":
+/*!************************************************!*\
+  !*** ../../node_modules/lodash/_baseCreate.js ***!
+  \************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var isObject = __webpack_require__(/*! ./isObject */ "../../node_modules/lodash/isObject.js");
+
+/** Built-in value references. */
+var objectCreate = Object.create;
+
+/**
+ * The base implementation of `_.create` without support for assigning
+ * properties to the created object.
+ *
+ * @private
+ * @param {Object} proto The object to inherit from.
+ * @returns {Object} Returns the new object.
+ */
+var baseCreate = (function() {
+  function object() {}
+  return function(proto) {
+    if (!isObject(proto)) {
+      return {};
+    }
+    if (objectCreate) {
+      return objectCreate(proto);
+    }
+    object.prototype = proto;
+    var result = new object;
+    object.prototype = undefined;
+    return result;
+  };
+}());
+
+module.exports = baseCreate;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_baseGetAllKeys.js":
+/*!****************************************************!*\
+  !*** ../../node_modules/lodash/_baseGetAllKeys.js ***!
+  \****************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var arrayPush = __webpack_require__(/*! ./_arrayPush */ "../../node_modules/lodash/_arrayPush.js"),
+    isArray = __webpack_require__(/*! ./isArray */ "../../node_modules/lodash/isArray.js");
+
+/**
+ * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
+ * `keysFunc` and `symbolsFunc` to get the enumerable property names and
+ * symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Function} keysFunc The function to get the keys of `object`.
+ * @param {Function} symbolsFunc The function to get the symbols of `object`.
+ * @returns {Array} Returns the array of property names and symbols.
+ */
+function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+  var result = keysFunc(object);
+  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
+}
+
+module.exports = baseGetAllKeys;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_baseGetTag.js":
+/*!************************************************!*\
+  !*** ../../node_modules/lodash/_baseGetTag.js ***!
+  \************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var Symbol = __webpack_require__(/*! ./_Symbol */ "../../node_modules/lodash/_Symbol.js"),
+    getRawTag = __webpack_require__(/*! ./_getRawTag */ "../../node_modules/lodash/_getRawTag.js"),
+    objectToString = __webpack_require__(/*! ./_objectToString */ "../../node_modules/lodash/_objectToString.js");
+
+/** `Object#toString` result references. */
+var nullTag = '[object Null]',
+    undefinedTag = '[object Undefined]';
+
+/** Built-in value references. */
+var symToStringTag = Symbol ? Symbol.toStringTag : undefined;
+
+/**
+ * The base implementation of `getTag` without fallbacks for buggy environments.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the `toStringTag`.
+ */
+function baseGetTag(value) {
+  if (value == null) {
+    return value === undefined ? undefinedTag : nullTag;
+  }
+  return (symToStringTag && symToStringTag in Object(value))
+    ? getRawTag(value)
+    : objectToString(value);
+}
+
+module.exports = baseGetTag;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_baseIsArguments.js":
+/*!*****************************************************!*\
+  !*** ../../node_modules/lodash/_baseIsArguments.js ***!
+  \*****************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var baseGetTag = __webpack_require__(/*! ./_baseGetTag */ "../../node_modules/lodash/_baseGetTag.js"),
+    isObjectLike = __webpack_require__(/*! ./isObjectLike */ "../../node_modules/lodash/isObjectLike.js");
+
+/** `Object#toString` result references. */
+var argsTag = '[object Arguments]';
+
+/**
+ * The base implementation of `_.isArguments`.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+ */
+function baseIsArguments(value) {
+  return isObjectLike(value) && baseGetTag(value) == argsTag;
+}
+
+module.exports = baseIsArguments;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_baseIsEqual.js":
+/*!*************************************************!*\
+  !*** ../../node_modules/lodash/_baseIsEqual.js ***!
+  \*************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var baseIsEqualDeep = __webpack_require__(/*! ./_baseIsEqualDeep */ "../../node_modules/lodash/_baseIsEqualDeep.js"),
+    isObjectLike = __webpack_require__(/*! ./isObjectLike */ "../../node_modules/lodash/isObjectLike.js");
+
+/**
+ * The base implementation of `_.isEqual` which supports partial comparisons
+ * and tracks traversed objects.
+ *
+ * @private
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @param {boolean} bitmask The bitmask flags.
+ *  1 - Unordered comparison
+ *  2 - Partial comparison
+ * @param {Function} [customizer] The function to customize comparisons.
+ * @param {Object} [stack] Tracks traversed `value` and `other` objects.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ */
+function baseIsEqual(value, other, bitmask, customizer, stack) {
+  if (value === other) {
+    return true;
+  }
+  if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {
+    return value !== value && other !== other;
+  }
+  return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
+}
+
+module.exports = baseIsEqual;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_baseIsEqualDeep.js":
+/*!*****************************************************!*\
+  !*** ../../node_modules/lodash/_baseIsEqualDeep.js ***!
+  \*****************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var Stack = __webpack_require__(/*! ./_Stack */ "../../node_modules/lodash/_Stack.js"),
+    equalArrays = __webpack_require__(/*! ./_equalArrays */ "../../node_modules/lodash/_equalArrays.js"),
+    equalByTag = __webpack_require__(/*! ./_equalByTag */ "../../node_modules/lodash/_equalByTag.js"),
+    equalObjects = __webpack_require__(/*! ./_equalObjects */ "../../node_modules/lodash/_equalObjects.js"),
+    getTag = __webpack_require__(/*! ./_getTag */ "../../node_modules/lodash/_getTag.js"),
+    isArray = __webpack_require__(/*! ./isArray */ "../../node_modules/lodash/isArray.js"),
+    isBuffer = __webpack_require__(/*! ./isBuffer */ "../../node_modules/lodash/isBuffer.js"),
+    isTypedArray = __webpack_require__(/*! ./isTypedArray */ "../../node_modules/lodash/isTypedArray.js");
+
+/** Used to compose bitmasks for value comparisons. */
+var COMPARE_PARTIAL_FLAG = 1;
+
+/** `Object#toString` result references. */
+var argsTag = '[object Arguments]',
+    arrayTag = '[object Array]',
+    objectTag = '[object Object]';
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * A specialized version of `baseIsEqual` for arrays and objects which performs
+ * deep comparisons and tracks traversed objects enabling objects with circular
+ * references to be compared.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Object} [stack] Tracks traversed `object` and `other` objects.
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+ */
+function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
+  var objIsArr = isArray(object),
+      othIsArr = isArray(other),
+      objTag = objIsArr ? arrayTag : getTag(object),
+      othTag = othIsArr ? arrayTag : getTag(other);
+
+  objTag = objTag == argsTag ? objectTag : objTag;
+  othTag = othTag == argsTag ? objectTag : othTag;
+
+  var objIsObj = objTag == objectTag,
+      othIsObj = othTag == objectTag,
+      isSameTag = objTag == othTag;
+
+  if (isSameTag && isBuffer(object)) {
+    if (!isBuffer(other)) {
+      return false;
+    }
+    objIsArr = true;
+    objIsObj = false;
+  }
+  if (isSameTag && !objIsObj) {
+    stack || (stack = new Stack);
+    return (objIsArr || isTypedArray(object))
+      ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)
+      : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
+  }
+  if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
+    var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
+        othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');
+
+    if (objIsWrapped || othIsWrapped) {
+      var objUnwrapped = objIsWrapped ? object.value() : object,
+          othUnwrapped = othIsWrapped ? other.value() : other;
+
+      stack || (stack = new Stack);
+      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+    }
+  }
+  if (!isSameTag) {
+    return false;
+  }
+  stack || (stack = new Stack);
+  return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
+}
+
+module.exports = baseIsEqualDeep;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_baseIsMap.js":
+/*!***********************************************!*\
+  !*** ../../node_modules/lodash/_baseIsMap.js ***!
+  \***********************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var getTag = __webpack_require__(/*! ./_getTag */ "../../node_modules/lodash/_getTag.js"),
+    isObjectLike = __webpack_require__(/*! ./isObjectLike */ "../../node_modules/lodash/isObjectLike.js");
+
+/** `Object#toString` result references. */
+var mapTag = '[object Map]';
+
+/**
+ * The base implementation of `_.isMap` without Node.js optimizations.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a map, else `false`.
+ */
+function baseIsMap(value) {
+  return isObjectLike(value) && getTag(value) == mapTag;
+}
+
+module.exports = baseIsMap;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_baseIsNative.js":
+/*!**************************************************!*\
+  !*** ../../node_modules/lodash/_baseIsNative.js ***!
+  \**************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var isFunction = __webpack_require__(/*! ./isFunction */ "../../node_modules/lodash/isFunction.js"),
+    isMasked = __webpack_require__(/*! ./_isMasked */ "../../node_modules/lodash/_isMasked.js"),
+    isObject = __webpack_require__(/*! ./isObject */ "../../node_modules/lodash/isObject.js"),
+    toSource = __webpack_require__(/*! ./_toSource */ "../../node_modules/lodash/_toSource.js");
+
+/**
+ * Used to match `RegExp`
+ * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
+ */
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+
+/** Used to detect host constructors (Safari). */
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+
+/** Used for built-in method references. */
+var funcProto = Function.prototype,
+    objectProto = Object.prototype;
+
+/** Used to resolve the decompiled source of functions. */
+var funcToString = funcProto.toString;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/** Used to detect if a method is native. */
+var reIsNative = RegExp('^' +
+  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
+  .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
+);
+
+/**
+ * The base implementation of `_.isNative` without bad shim checks.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a native function,
+ *  else `false`.
+ */
+function baseIsNative(value) {
+  if (!isObject(value) || isMasked(value)) {
+    return false;
+  }
+  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource(value));
+}
+
+module.exports = baseIsNative;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_baseIsSet.js":
+/*!***********************************************!*\
+  !*** ../../node_modules/lodash/_baseIsSet.js ***!
+  \***********************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var getTag = __webpack_require__(/*! ./_getTag */ "../../node_modules/lodash/_getTag.js"),
+    isObjectLike = __webpack_require__(/*! ./isObjectLike */ "../../node_modules/lodash/isObjectLike.js");
+
+/** `Object#toString` result references. */
+var setTag = '[object Set]';
+
+/**
+ * The base implementation of `_.isSet` without Node.js optimizations.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a set, else `false`.
+ */
+function baseIsSet(value) {
+  return isObjectLike(value) && getTag(value) == setTag;
+}
+
+module.exports = baseIsSet;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_baseIsTypedArray.js":
+/*!******************************************************!*\
+  !*** ../../node_modules/lodash/_baseIsTypedArray.js ***!
+  \******************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var baseGetTag = __webpack_require__(/*! ./_baseGetTag */ "../../node_modules/lodash/_baseGetTag.js"),
+    isLength = __webpack_require__(/*! ./isLength */ "../../node_modules/lodash/isLength.js"),
+    isObjectLike = __webpack_require__(/*! ./isObjectLike */ "../../node_modules/lodash/isObjectLike.js");
+
+/** `Object#toString` result references. */
+var argsTag = '[object Arguments]',
+    arrayTag = '[object Array]',
+    boolTag = '[object Boolean]',
+    dateTag = '[object Date]',
+    errorTag = '[object Error]',
+    funcTag = '[object Function]',
+    mapTag = '[object Map]',
+    numberTag = '[object Number]',
+    objectTag = '[object Object]',
+    regexpTag = '[object RegExp]',
+    setTag = '[object Set]',
+    stringTag = '[object String]',
+    weakMapTag = '[object WeakMap]';
+
+var arrayBufferTag = '[object ArrayBuffer]',
+    dataViewTag = '[object DataView]',
+    float32Tag = '[object Float32Array]',
+    float64Tag = '[object Float64Array]',
+    int8Tag = '[object Int8Array]',
+    int16Tag = '[object Int16Array]',
+    int32Tag = '[object Int32Array]',
+    uint8Tag = '[object Uint8Array]',
+    uint8ClampedTag = '[object Uint8ClampedArray]',
+    uint16Tag = '[object Uint16Array]',
+    uint32Tag = '[object Uint32Array]';
+
+/** Used to identify `toStringTag` values of typed arrays. */
+var typedArrayTags = {};
+typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
+typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
+typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
+typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
+typedArrayTags[uint32Tag] = true;
+typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
+typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
+typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
+typedArrayTags[errorTag] = typedArrayTags[funcTag] =
+typedArrayTags[mapTag] = typedArrayTags[numberTag] =
+typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
+typedArrayTags[setTag] = typedArrayTags[stringTag] =
+typedArrayTags[weakMapTag] = false;
+
+/**
+ * The base implementation of `_.isTypedArray` without Node.js optimizations.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+ */
+function baseIsTypedArray(value) {
+  return isObjectLike(value) &&
+    isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
+}
+
+module.exports = baseIsTypedArray;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_baseKeys.js":
+/*!**********************************************!*\
+  !*** ../../node_modules/lodash/_baseKeys.js ***!
+  \**********************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var isPrototype = __webpack_require__(/*! ./_isPrototype */ "../../node_modules/lodash/_isPrototype.js"),
+    nativeKeys = __webpack_require__(/*! ./_nativeKeys */ "../../node_modules/lodash/_nativeKeys.js");
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ */
+function baseKeys(object) {
+  if (!isPrototype(object)) {
+    return nativeKeys(object);
+  }
+  var result = [];
+  for (var key in Object(object)) {
+    if (hasOwnProperty.call(object, key) && key != 'constructor') {
+      result.push(key);
+    }
+  }
+  return result;
+}
+
+module.exports = baseKeys;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_baseKeysIn.js":
+/*!************************************************!*\
+  !*** ../../node_modules/lodash/_baseKeysIn.js ***!
+  \************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var isObject = __webpack_require__(/*! ./isObject */ "../../node_modules/lodash/isObject.js"),
+    isPrototype = __webpack_require__(/*! ./_isPrototype */ "../../node_modules/lodash/_isPrototype.js"),
+    nativeKeysIn = __webpack_require__(/*! ./_nativeKeysIn */ "../../node_modules/lodash/_nativeKeysIn.js");
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ */
+function baseKeysIn(object) {
+  if (!isObject(object)) {
+    return nativeKeysIn(object);
+  }
+  var isProto = isPrototype(object),
+      result = [];
+
+  for (var key in object) {
+    if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+
+module.exports = baseKeysIn;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_baseTimes.js":
+/*!***********************************************!*\
+  !*** ../../node_modules/lodash/_baseTimes.js ***!
+  \***********************************************/
+/***/ ((module) => {
+
+/**
+ * The base implementation of `_.times` without support for iteratee shorthands
+ * or max array length checks.
+ *
+ * @private
+ * @param {number} n The number of times to invoke `iteratee`.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns the array of results.
+ */
+function baseTimes(n, iteratee) {
+  var index = -1,
+      result = Array(n);
+
+  while (++index < n) {
+    result[index] = iteratee(index);
+  }
+  return result;
+}
+
+module.exports = baseTimes;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_baseUnary.js":
+/*!***********************************************!*\
+  !*** ../../node_modules/lodash/_baseUnary.js ***!
+  \***********************************************/
+/***/ ((module) => {
+
+/**
+ * The base implementation of `_.unary` without support for storing metadata.
+ *
+ * @private
+ * @param {Function} func The function to cap arguments for.
+ * @returns {Function} Returns the new capped function.
+ */
+function baseUnary(func) {
+  return function(value) {
+    return func(value);
+  };
+}
+
+module.exports = baseUnary;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_cacheHas.js":
+/*!**********************************************!*\
+  !*** ../../node_modules/lodash/_cacheHas.js ***!
+  \**********************************************/
+/***/ ((module) => {
+
+/**
+ * Checks if a `cache` value for `key` exists.
+ *
+ * @private
+ * @param {Object} cache The cache to query.
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function cacheHas(cache, key) {
+  return cache.has(key);
+}
+
+module.exports = cacheHas;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_cloneArrayBuffer.js":
+/*!******************************************************!*\
+  !*** ../../node_modules/lodash/_cloneArrayBuffer.js ***!
+  \******************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var Uint8Array = __webpack_require__(/*! ./_Uint8Array */ "../../node_modules/lodash/_Uint8Array.js");
+
+/**
+ * Creates a clone of `arrayBuffer`.
+ *
+ * @private
+ * @param {ArrayBuffer} arrayBuffer The array buffer to clone.
+ * @returns {ArrayBuffer} Returns the cloned array buffer.
+ */
+function cloneArrayBuffer(arrayBuffer) {
+  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+  new Uint8Array(result).set(new Uint8Array(arrayBuffer));
+  return result;
+}
+
+module.exports = cloneArrayBuffer;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_cloneBuffer.js":
+/*!*************************************************!*\
+  !*** ../../node_modules/lodash/_cloneBuffer.js ***!
+  \*************************************************/
+/***/ ((module, exports, __webpack_require__) => {
+
+/* module decorator */ module = __webpack_require__.nmd(module);
+var root = __webpack_require__(/*! ./_root */ "../../node_modules/lodash/_root.js");
+
+/** Detect free variable `exports`. */
+var freeExports =  true && exports && !exports.nodeType && exports;
+
+/** Detect free variable `module`. */
+var freeModule = freeExports && "object" == 'object' && module && !module.nodeType && module;
+
+/** Detect the popular CommonJS extension `module.exports`. */
+var moduleExports = freeModule && freeModule.exports === freeExports;
+
+/** Built-in value references. */
+var Buffer = moduleExports ? root.Buffer : undefined,
+    allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined;
+
+/**
+ * Creates a clone of  `buffer`.
+ *
+ * @private
+ * @param {Buffer} buffer The buffer to clone.
+ * @param {boolean} [isDeep] Specify a deep clone.
+ * @returns {Buffer} Returns the cloned buffer.
+ */
+function cloneBuffer(buffer, isDeep) {
+  if (isDeep) {
+    return buffer.slice();
+  }
+  var length = buffer.length,
+      result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
+
+  buffer.copy(result);
+  return result;
+}
+
+module.exports = cloneBuffer;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_cloneDataView.js":
+/*!***************************************************!*\
+  !*** ../../node_modules/lodash/_cloneDataView.js ***!
+  \***************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var cloneArrayBuffer = __webpack_require__(/*! ./_cloneArrayBuffer */ "../../node_modules/lodash/_cloneArrayBuffer.js");
+
+/**
+ * Creates a clone of `dataView`.
+ *
+ * @private
+ * @param {Object} dataView The data view to clone.
+ * @param {boolean} [isDeep] Specify a deep clone.
+ * @returns {Object} Returns the cloned data view.
+ */
+function cloneDataView(dataView, isDeep) {
+  var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
+  return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
+}
+
+module.exports = cloneDataView;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_cloneRegExp.js":
+/*!*************************************************!*\
+  !*** ../../node_modules/lodash/_cloneRegExp.js ***!
+  \*************************************************/
+/***/ ((module) => {
+
+/** Used to match `RegExp` flags from their coerced string values. */
+var reFlags = /\w*$/;
+
+/**
+ * Creates a clone of `regexp`.
+ *
+ * @private
+ * @param {Object} regexp The regexp to clone.
+ * @returns {Object} Returns the cloned regexp.
+ */
+function cloneRegExp(regexp) {
+  var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
+  result.lastIndex = regexp.lastIndex;
+  return result;
+}
+
+module.exports = cloneRegExp;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_cloneSymbol.js":
+/*!*************************************************!*\
+  !*** ../../node_modules/lodash/_cloneSymbol.js ***!
+  \*************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var Symbol = __webpack_require__(/*! ./_Symbol */ "../../node_modules/lodash/_Symbol.js");
+
+/** Used to convert symbols to primitives and strings. */
+var symbolProto = Symbol ? Symbol.prototype : undefined,
+    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;
+
+/**
+ * Creates a clone of the `symbol` object.
+ *
+ * @private
+ * @param {Object} symbol The symbol object to clone.
+ * @returns {Object} Returns the cloned symbol object.
+ */
+function cloneSymbol(symbol) {
+  return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
+}
+
+module.exports = cloneSymbol;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_cloneTypedArray.js":
+/*!*****************************************************!*\
+  !*** ../../node_modules/lodash/_cloneTypedArray.js ***!
+  \*****************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var cloneArrayBuffer = __webpack_require__(/*! ./_cloneArrayBuffer */ "../../node_modules/lodash/_cloneArrayBuffer.js");
+
+/**
+ * Creates a clone of `typedArray`.
+ *
+ * @private
+ * @param {Object} typedArray The typed array to clone.
+ * @param {boolean} [isDeep] Specify a deep clone.
+ * @returns {Object} Returns the cloned typed array.
+ */
+function cloneTypedArray(typedArray, isDeep) {
+  var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
+  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
+}
+
+module.exports = cloneTypedArray;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_copyArray.js":
+/*!***********************************************!*\
+  !*** ../../node_modules/lodash/_copyArray.js ***!
+  \***********************************************/
+/***/ ((module) => {
+
+/**
+ * Copies the values of `source` to `array`.
+ *
+ * @private
+ * @param {Array} source The array to copy values from.
+ * @param {Array} [array=[]] The array to copy values to.
+ * @returns {Array} Returns `array`.
+ */
+function copyArray(source, array) {
+  var index = -1,
+      length = source.length;
+
+  array || (array = Array(length));
+  while (++index < length) {
+    array[index] = source[index];
+  }
+  return array;
+}
+
+module.exports = copyArray;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_copyObject.js":
+/*!************************************************!*\
+  !*** ../../node_modules/lodash/_copyObject.js ***!
+  \************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var assignValue = __webpack_require__(/*! ./_assignValue */ "../../node_modules/lodash/_assignValue.js"),
+    baseAssignValue = __webpack_require__(/*! ./_baseAssignValue */ "../../node_modules/lodash/_baseAssignValue.js");
+
+/**
+ * Copies properties of `source` to `object`.
+ *
+ * @private
+ * @param {Object} source The object to copy properties from.
+ * @param {Array} props The property identifiers to copy.
+ * @param {Object} [object={}] The object to copy properties to.
+ * @param {Function} [customizer] The function to customize copied values.
+ * @returns {Object} Returns `object`.
+ */
+function copyObject(source, props, object, customizer) {
+  var isNew = !object;
+  object || (object = {});
+
+  var index = -1,
+      length = props.length;
+
+  while (++index < length) {
+    var key = props[index];
+
+    var newValue = customizer
+      ? customizer(object[key], source[key], key, object, source)
+      : undefined;
+
+    if (newValue === undefined) {
+      newValue = source[key];
+    }
+    if (isNew) {
+      baseAssignValue(object, key, newValue);
+    } else {
+      assignValue(object, key, newValue);
+    }
+  }
+  return object;
+}
+
+module.exports = copyObject;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_copySymbols.js":
+/*!*************************************************!*\
+  !*** ../../node_modules/lodash/_copySymbols.js ***!
+  \*************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var copyObject = __webpack_require__(/*! ./_copyObject */ "../../node_modules/lodash/_copyObject.js"),
+    getSymbols = __webpack_require__(/*! ./_getSymbols */ "../../node_modules/lodash/_getSymbols.js");
+
+/**
+ * Copies own symbols of `source` to `object`.
+ *
+ * @private
+ * @param {Object} source The object to copy symbols from.
+ * @param {Object} [object={}] The object to copy symbols to.
+ * @returns {Object} Returns `object`.
+ */
+function copySymbols(source, object) {
+  return copyObject(source, getSymbols(source), object);
+}
+
+module.exports = copySymbols;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_copySymbolsIn.js":
+/*!***************************************************!*\
+  !*** ../../node_modules/lodash/_copySymbolsIn.js ***!
+  \***************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var copyObject = __webpack_require__(/*! ./_copyObject */ "../../node_modules/lodash/_copyObject.js"),
+    getSymbolsIn = __webpack_require__(/*! ./_getSymbolsIn */ "../../node_modules/lodash/_getSymbolsIn.js");
+
+/**
+ * Copies own and inherited symbols of `source` to `object`.
+ *
+ * @private
+ * @param {Object} source The object to copy symbols from.
+ * @param {Object} [object={}] The object to copy symbols to.
+ * @returns {Object} Returns `object`.
+ */
+function copySymbolsIn(source, object) {
+  return copyObject(source, getSymbolsIn(source), object);
+}
+
+module.exports = copySymbolsIn;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_coreJsData.js":
+/*!************************************************!*\
+  !*** ../../node_modules/lodash/_coreJsData.js ***!
+  \************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var root = __webpack_require__(/*! ./_root */ "../../node_modules/lodash/_root.js");
+
+/** Used to detect overreaching core-js shims. */
+var coreJsData = root['__core-js_shared__'];
+
+module.exports = coreJsData;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_defineProperty.js":
+/*!****************************************************!*\
+  !*** ../../node_modules/lodash/_defineProperty.js ***!
+  \****************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var getNative = __webpack_require__(/*! ./_getNative */ "../../node_modules/lodash/_getNative.js");
+
+var defineProperty = (function() {
+  try {
+    var func = getNative(Object, 'defineProperty');
+    func({}, '', {});
+    return func;
+  } catch (e) {}
+}());
+
+module.exports = defineProperty;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_equalArrays.js":
+/*!*************************************************!*\
+  !*** ../../node_modules/lodash/_equalArrays.js ***!
+  \*************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var SetCache = __webpack_require__(/*! ./_SetCache */ "../../node_modules/lodash/_SetCache.js"),
+    arraySome = __webpack_require__(/*! ./_arraySome */ "../../node_modules/lodash/_arraySome.js"),
+    cacheHas = __webpack_require__(/*! ./_cacheHas */ "../../node_modules/lodash/_cacheHas.js");
+
+/** Used to compose bitmasks for value comparisons. */
+var COMPARE_PARTIAL_FLAG = 1,
+    COMPARE_UNORDERED_FLAG = 2;
+
+/**
+ * A specialized version of `baseIsEqualDeep` for arrays with support for
+ * partial deep comparisons.
+ *
+ * @private
+ * @param {Array} array The array to compare.
+ * @param {Array} other The other array to compare.
+ * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Object} stack Tracks traversed `array` and `other` objects.
+ * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
+ */
+function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
+      arrLength = array.length,
+      othLength = other.length;
+
+  if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
+    return false;
+  }
+  // Check that cyclic values are equal.
+  var arrStacked = stack.get(array);
+  var othStacked = stack.get(other);
+  if (arrStacked && othStacked) {
+    return arrStacked == other && othStacked == array;
+  }
+  var index = -1,
+      result = true,
+      seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;
+
+  stack.set(array, other);
+  stack.set(other, array);
+
+  // Ignore non-index properties.
+  while (++index < arrLength) {
+    var arrValue = array[index],
+        othValue = other[index];
+
+    if (customizer) {
+      var compared = isPartial
+        ? customizer(othValue, arrValue, index, other, array, stack)
+        : customizer(arrValue, othValue, index, array, other, stack);
+    }
+    if (compared !== undefined) {
+      if (compared) {
+        continue;
+      }
+      result = false;
+      break;
+    }
+    // Recursively compare arrays (susceptible to call stack limits).
+    if (seen) {
+      if (!arraySome(other, function(othValue, othIndex) {
+            if (!cacheHas(seen, othIndex) &&
+                (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+              return seen.push(othIndex);
+            }
+          })) {
+        result = false;
+        break;
+      }
+    } else if (!(
+          arrValue === othValue ||
+            equalFunc(arrValue, othValue, bitmask, customizer, stack)
+        )) {
+      result = false;
+      break;
+    }
+  }
+  stack['delete'](array);
+  stack['delete'](other);
+  return result;
+}
+
+module.exports = equalArrays;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_equalByTag.js":
+/*!************************************************!*\
+  !*** ../../node_modules/lodash/_equalByTag.js ***!
+  \************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var Symbol = __webpack_require__(/*! ./_Symbol */ "../../node_modules/lodash/_Symbol.js"),
+    Uint8Array = __webpack_require__(/*! ./_Uint8Array */ "../../node_modules/lodash/_Uint8Array.js"),
+    eq = __webpack_require__(/*! ./eq */ "../../node_modules/lodash/eq.js"),
+    equalArrays = __webpack_require__(/*! ./_equalArrays */ "../../node_modules/lodash/_equalArrays.js"),
+    mapToArray = __webpack_require__(/*! ./_mapToArray */ "../../node_modules/lodash/_mapToArray.js"),
+    setToArray = __webpack_require__(/*! ./_setToArray */ "../../node_modules/lodash/_setToArray.js");
+
+/** Used to compose bitmasks for value comparisons. */
+var COMPARE_PARTIAL_FLAG = 1,
+    COMPARE_UNORDERED_FLAG = 2;
+
+/** `Object#toString` result references. */
+var boolTag = '[object Boolean]',
+    dateTag = '[object Date]',
+    errorTag = '[object Error]',
+    mapTag = '[object Map]',
+    numberTag = '[object Number]',
+    regexpTag = '[object RegExp]',
+    setTag = '[object Set]',
+    stringTag = '[object String]',
+    symbolTag = '[object Symbol]';
+
+var arrayBufferTag = '[object ArrayBuffer]',
+    dataViewTag = '[object DataView]';
+
+/** Used to convert symbols to primitives and strings. */
+var symbolProto = Symbol ? Symbol.prototype : undefined,
+    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;
+
+/**
+ * A specialized version of `baseIsEqualDeep` for comparing objects of
+ * the same `toStringTag`.
+ *
+ * **Note:** This function only supports comparing values with tags of
+ * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {string} tag The `toStringTag` of the objects to compare.
+ * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Object} stack Tracks traversed `object` and `other` objects.
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+ */
+function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
+  switch (tag) {
+    case dataViewTag:
+      if ((object.byteLength != other.byteLength) ||
+          (object.byteOffset != other.byteOffset)) {
+        return false;
+      }
+      object = object.buffer;
+      other = other.buffer;
+
+    case arrayBufferTag:
+      if ((object.byteLength != other.byteLength) ||
+          !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
+        return false;
+      }
+      return true;
+
+    case boolTag:
+    case dateTag:
+    case numberTag:
+      // Coerce booleans to `1` or `0` and dates to milliseconds.
+      // Invalid dates are coerced to `NaN`.
+      return eq(+object, +other);
+
+    case errorTag:
+      return object.name == other.name && object.message == other.message;
+
+    case regexpTag:
+    case stringTag:
+      // Coerce regexes to strings and treat strings, primitives and objects,
+      // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring
+      // for more details.
+      return object == (other + '');
+
+    case mapTag:
+      var convert = mapToArray;
+
+    case setTag:
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
+      convert || (convert = setToArray);
+
+      if (object.size != other.size && !isPartial) {
+        return false;
+      }
+      // Assume cyclic values are equal.
+      var stacked = stack.get(object);
+      if (stacked) {
+        return stacked == other;
+      }
+      bitmask |= COMPARE_UNORDERED_FLAG;
+
+      // Recursively compare objects (susceptible to call stack limits).
+      stack.set(object, other);
+      var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+      stack['delete'](object);
+      return result;
+
+    case symbolTag:
+      if (symbolValueOf) {
+        return symbolValueOf.call(object) == symbolValueOf.call(other);
+      }
+  }
+  return false;
+}
+
+module.exports = equalByTag;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_equalObjects.js":
+/*!**************************************************!*\
+  !*** ../../node_modules/lodash/_equalObjects.js ***!
+  \**************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var getAllKeys = __webpack_require__(/*! ./_getAllKeys */ "../../node_modules/lodash/_getAllKeys.js");
+
+/** Used to compose bitmasks for value comparisons. */
+var COMPARE_PARTIAL_FLAG = 1;
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * A specialized version of `baseIsEqualDeep` for objects with support for
+ * partial deep comparisons.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Object} stack Tracks traversed `object` and `other` objects.
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+ */
+function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
+      objProps = getAllKeys(object),
+      objLength = objProps.length,
+      othProps = getAllKeys(other),
+      othLength = othProps.length;
+
+  if (objLength != othLength && !isPartial) {
+    return false;
+  }
+  var index = objLength;
+  while (index--) {
+    var key = objProps[index];
+    if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
+      return false;
+    }
+  }
+  // Check that cyclic values are equal.
+  var objStacked = stack.get(object);
+  var othStacked = stack.get(other);
+  if (objStacked && othStacked) {
+    return objStacked == other && othStacked == object;
+  }
+  var result = true;
+  stack.set(object, other);
+  stack.set(other, object);
+
+  var skipCtor = isPartial;
+  while (++index < objLength) {
+    key = objProps[index];
+    var objValue = object[key],
+        othValue = other[key];
+
+    if (customizer) {
+      var compared = isPartial
+        ? customizer(othValue, objValue, key, other, object, stack)
+        : customizer(objValue, othValue, key, object, other, stack);
+    }
+    // Recursively compare objects (susceptible to call stack limits).
+    if (!(compared === undefined
+          ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))
+          : compared
+        )) {
+      result = false;
+      break;
+    }
+    skipCtor || (skipCtor = key == 'constructor');
+  }
+  if (result && !skipCtor) {
+    var objCtor = object.constructor,
+        othCtor = other.constructor;
+
+    // Non `Object` object instances with different constructors are not equal.
+    if (objCtor != othCtor &&
+        ('constructor' in object && 'constructor' in other) &&
+        !(typeof objCtor == 'function' && objCtor instanceof objCtor &&
+          typeof othCtor == 'function' && othCtor instanceof othCtor)) {
+      result = false;
+    }
+  }
+  stack['delete'](object);
+  stack['delete'](other);
+  return result;
+}
+
+module.exports = equalObjects;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_freeGlobal.js":
+/*!************************************************!*\
+  !*** ../../node_modules/lodash/_freeGlobal.js ***!
+  \************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+/** Detect free variable `global` from Node.js. */
+var freeGlobal = typeof __webpack_require__.g == 'object' && __webpack_require__.g && __webpack_require__.g.Object === Object && __webpack_require__.g;
+
+module.exports = freeGlobal;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_getAllKeys.js":
+/*!************************************************!*\
+  !*** ../../node_modules/lodash/_getAllKeys.js ***!
+  \************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var baseGetAllKeys = __webpack_require__(/*! ./_baseGetAllKeys */ "../../node_modules/lodash/_baseGetAllKeys.js"),
+    getSymbols = __webpack_require__(/*! ./_getSymbols */ "../../node_modules/lodash/_getSymbols.js"),
+    keys = __webpack_require__(/*! ./keys */ "../../node_modules/lodash/keys.js");
+
+/**
+ * Creates an array of own enumerable property names and symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names and symbols.
+ */
+function getAllKeys(object) {
+  return baseGetAllKeys(object, keys, getSymbols);
+}
+
+module.exports = getAllKeys;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_getAllKeysIn.js":
+/*!**************************************************!*\
+  !*** ../../node_modules/lodash/_getAllKeysIn.js ***!
+  \**************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var baseGetAllKeys = __webpack_require__(/*! ./_baseGetAllKeys */ "../../node_modules/lodash/_baseGetAllKeys.js"),
+    getSymbolsIn = __webpack_require__(/*! ./_getSymbolsIn */ "../../node_modules/lodash/_getSymbolsIn.js"),
+    keysIn = __webpack_require__(/*! ./keysIn */ "../../node_modules/lodash/keysIn.js");
+
+/**
+ * Creates an array of own and inherited enumerable property names and
+ * symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names and symbols.
+ */
+function getAllKeysIn(object) {
+  return baseGetAllKeys(object, keysIn, getSymbolsIn);
+}
+
+module.exports = getAllKeysIn;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_getMapData.js":
+/*!************************************************!*\
+  !*** ../../node_modules/lodash/_getMapData.js ***!
+  \************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var isKeyable = __webpack_require__(/*! ./_isKeyable */ "../../node_modules/lodash/_isKeyable.js");
+
+/**
+ * Gets the data for `map`.
+ *
+ * @private
+ * @param {Object} map The map to query.
+ * @param {string} key The reference key.
+ * @returns {*} Returns the map data.
+ */
+function getMapData(map, key) {
+  var data = map.__data__;
+  return isKeyable(key)
+    ? data[typeof key == 'string' ? 'string' : 'hash']
+    : data.map;
+}
+
+module.exports = getMapData;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_getNative.js":
+/*!***********************************************!*\
+  !*** ../../node_modules/lodash/_getNative.js ***!
+  \***********************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var baseIsNative = __webpack_require__(/*! ./_baseIsNative */ "../../node_modules/lodash/_baseIsNative.js"),
+    getValue = __webpack_require__(/*! ./_getValue */ "../../node_modules/lodash/_getValue.js");
+
+/**
+ * Gets the native function at `key` of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {string} key The key of the method to get.
+ * @returns {*} Returns the function if it's native, else `undefined`.
+ */
+function getNative(object, key) {
+  var value = getValue(object, key);
+  return baseIsNative(value) ? value : undefined;
+}
+
+module.exports = getNative;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_getPrototype.js":
+/*!**************************************************!*\
+  !*** ../../node_modules/lodash/_getPrototype.js ***!
+  \**************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var overArg = __webpack_require__(/*! ./_overArg */ "../../node_modules/lodash/_overArg.js");
+
+/** Built-in value references. */
+var getPrototype = overArg(Object.getPrototypeOf, Object);
+
+module.exports = getPrototype;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_getRawTag.js":
+/*!***********************************************!*\
+  !*** ../../node_modules/lodash/_getRawTag.js ***!
+  \***********************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var Symbol = __webpack_require__(/*! ./_Symbol */ "../../node_modules/lodash/_Symbol.js");
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var nativeObjectToString = objectProto.toString;
+
+/** Built-in value references. */
+var symToStringTag = Symbol ? Symbol.toStringTag : undefined;
+
+/**
+ * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the raw `toStringTag`.
+ */
+function getRawTag(value) {
+  var isOwn = hasOwnProperty.call(value, symToStringTag),
+      tag = value[symToStringTag];
+
+  try {
+    value[symToStringTag] = undefined;
+    var unmasked = true;
+  } catch (e) {}
+
+  var result = nativeObjectToString.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag] = tag;
+    } else {
+      delete value[symToStringTag];
+    }
+  }
+  return result;
+}
+
+module.exports = getRawTag;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_getSymbols.js":
+/*!************************************************!*\
+  !*** ../../node_modules/lodash/_getSymbols.js ***!
+  \************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var arrayFilter = __webpack_require__(/*! ./_arrayFilter */ "../../node_modules/lodash/_arrayFilter.js"),
+    stubArray = __webpack_require__(/*! ./stubArray */ "../../node_modules/lodash/stubArray.js");
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Built-in value references. */
+var propertyIsEnumerable = objectProto.propertyIsEnumerable;
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeGetSymbols = Object.getOwnPropertySymbols;
+
+/**
+ * Creates an array of the own enumerable symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of symbols.
+ */
+var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
+  if (object == null) {
+    return [];
+  }
+  object = Object(object);
+  return arrayFilter(nativeGetSymbols(object), function(symbol) {
+    return propertyIsEnumerable.call(object, symbol);
+  });
+};
+
+module.exports = getSymbols;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_getSymbolsIn.js":
+/*!**************************************************!*\
+  !*** ../../node_modules/lodash/_getSymbolsIn.js ***!
+  \**************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var arrayPush = __webpack_require__(/*! ./_arrayPush */ "../../node_modules/lodash/_arrayPush.js"),
+    getPrototype = __webpack_require__(/*! ./_getPrototype */ "../../node_modules/lodash/_getPrototype.js"),
+    getSymbols = __webpack_require__(/*! ./_getSymbols */ "../../node_modules/lodash/_getSymbols.js"),
+    stubArray = __webpack_require__(/*! ./stubArray */ "../../node_modules/lodash/stubArray.js");
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeGetSymbols = Object.getOwnPropertySymbols;
+
+/**
+ * Creates an array of the own and inherited enumerable symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of symbols.
+ */
+var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {
+  var result = [];
+  while (object) {
+    arrayPush(result, getSymbols(object));
+    object = getPrototype(object);
+  }
+  return result;
+};
+
+module.exports = getSymbolsIn;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_getTag.js":
+/*!********************************************!*\
+  !*** ../../node_modules/lodash/_getTag.js ***!
+  \********************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var DataView = __webpack_require__(/*! ./_DataView */ "../../node_modules/lodash/_DataView.js"),
+    Map = __webpack_require__(/*! ./_Map */ "../../node_modules/lodash/_Map.js"),
+    Promise = __webpack_require__(/*! ./_Promise */ "../../node_modules/lodash/_Promise.js"),
+    Set = __webpack_require__(/*! ./_Set */ "../../node_modules/lodash/_Set.js"),
+    WeakMap = __webpack_require__(/*! ./_WeakMap */ "../../node_modules/lodash/_WeakMap.js"),
+    baseGetTag = __webpack_require__(/*! ./_baseGetTag */ "../../node_modules/lodash/_baseGetTag.js"),
+    toSource = __webpack_require__(/*! ./_toSource */ "../../node_modules/lodash/_toSource.js");
+
+/** `Object#toString` result references. */
+var mapTag = '[object Map]',
+    objectTag = '[object Object]',
+    promiseTag = '[object Promise]',
+    setTag = '[object Set]',
+    weakMapTag = '[object WeakMap]';
+
+var dataViewTag = '[object DataView]';
+
+/** Used to detect maps, sets, and weakmaps. */
+var dataViewCtorString = toSource(DataView),
+    mapCtorString = toSource(Map),
+    promiseCtorString = toSource(Promise),
+    setCtorString = toSource(Set),
+    weakMapCtorString = toSource(WeakMap);
+
+/**
+ * Gets the `toStringTag` of `value`.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the `toStringTag`.
+ */
+var getTag = baseGetTag;
+
+// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
+if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
+    (Map && getTag(new Map) != mapTag) ||
+    (Promise && getTag(Promise.resolve()) != promiseTag) ||
+    (Set && getTag(new Set) != setTag) ||
+    (WeakMap && getTag(new WeakMap) != weakMapTag)) {
+  getTag = function(value) {
+    var result = baseGetTag(value),
+        Ctor = result == objectTag ? value.constructor : undefined,
+        ctorString = Ctor ? toSource(Ctor) : '';
+
+    if (ctorString) {
+      switch (ctorString) {
+        case dataViewCtorString: return dataViewTag;
+        case mapCtorString: return mapTag;
+        case promiseCtorString: return promiseTag;
+        case setCtorString: return setTag;
+        case weakMapCtorString: return weakMapTag;
+      }
+    }
+    return result;
+  };
+}
+
+module.exports = getTag;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_getValue.js":
+/*!**********************************************!*\
+  !*** ../../node_modules/lodash/_getValue.js ***!
+  \**********************************************/
+/***/ ((module) => {
+
+/**
+ * Gets the value at `key` of `object`.
+ *
+ * @private
+ * @param {Object} [object] The object to query.
+ * @param {string} key The key of the property to get.
+ * @returns {*} Returns the property value.
+ */
+function getValue(object, key) {
+  return object == null ? undefined : object[key];
+}
+
+module.exports = getValue;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_hashClear.js":
+/*!***********************************************!*\
+  !*** ../../node_modules/lodash/_hashClear.js ***!
+  \***********************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var nativeCreate = __webpack_require__(/*! ./_nativeCreate */ "../../node_modules/lodash/_nativeCreate.js");
+
+/**
+ * Removes all key-value entries from the hash.
+ *
+ * @private
+ * @name clear
+ * @memberOf Hash
+ */
+function hashClear() {
+  this.__data__ = nativeCreate ? nativeCreate(null) : {};
+  this.size = 0;
+}
+
+module.exports = hashClear;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_hashDelete.js":
+/*!************************************************!*\
+  !*** ../../node_modules/lodash/_hashDelete.js ***!
+  \************************************************/
+/***/ ((module) => {
+
+/**
+ * Removes `key` and its value from the hash.
+ *
+ * @private
+ * @name delete
+ * @memberOf Hash
+ * @param {Object} hash The hash to modify.
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function hashDelete(key) {
+  var result = this.has(key) && delete this.__data__[key];
+  this.size -= result ? 1 : 0;
+  return result;
+}
+
+module.exports = hashDelete;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_hashGet.js":
+/*!*********************************************!*\
+  !*** ../../node_modules/lodash/_hashGet.js ***!
+  \*********************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var nativeCreate = __webpack_require__(/*! ./_nativeCreate */ "../../node_modules/lodash/_nativeCreate.js");
+
+/** Used to stand-in for `undefined` hash values. */
+var HASH_UNDEFINED = '__lodash_hash_undefined__';
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Gets the hash value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf Hash
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function hashGet(key) {
+  var data = this.__data__;
+  if (nativeCreate) {
+    var result = data[key];
+    return result === HASH_UNDEFINED ? undefined : result;
+  }
+  return hasOwnProperty.call(data, key) ? data[key] : undefined;
+}
+
+module.exports = hashGet;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_hashHas.js":
+/*!*********************************************!*\
+  !*** ../../node_modules/lodash/_hashHas.js ***!
+  \*********************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var nativeCreate = __webpack_require__(/*! ./_nativeCreate */ "../../node_modules/lodash/_nativeCreate.js");
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Checks if a hash value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf Hash
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function hashHas(key) {
+  var data = this.__data__;
+  return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);
+}
+
+module.exports = hashHas;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_hashSet.js":
+/*!*********************************************!*\
+  !*** ../../node_modules/lodash/_hashSet.js ***!
+  \*********************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var nativeCreate = __webpack_require__(/*! ./_nativeCreate */ "../../node_modules/lodash/_nativeCreate.js");
+
+/** Used to stand-in for `undefined` hash values. */
+var HASH_UNDEFINED = '__lodash_hash_undefined__';
+
+/**
+ * Sets the hash `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf Hash
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the hash instance.
+ */
+function hashSet(key, value) {
+  var data = this.__data__;
+  this.size += this.has(key) ? 0 : 1;
+  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
+  return this;
+}
+
+module.exports = hashSet;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_initCloneArray.js":
+/*!****************************************************!*\
+  !*** ../../node_modules/lodash/_initCloneArray.js ***!
+  \****************************************************/
+/***/ ((module) => {
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Initializes an array clone.
+ *
+ * @private
+ * @param {Array} array The array to clone.
+ * @returns {Array} Returns the initialized clone.
+ */
+function initCloneArray(array) {
+  var length = array.length,
+      result = new array.constructor(length);
+
+  // Add properties assigned by `RegExp#exec`.
+  if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {
+    result.index = array.index;
+    result.input = array.input;
+  }
+  return result;
+}
+
+module.exports = initCloneArray;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_initCloneByTag.js":
+/*!****************************************************!*\
+  !*** ../../node_modules/lodash/_initCloneByTag.js ***!
+  \****************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var cloneArrayBuffer = __webpack_require__(/*! ./_cloneArrayBuffer */ "../../node_modules/lodash/_cloneArrayBuffer.js"),
+    cloneDataView = __webpack_require__(/*! ./_cloneDataView */ "../../node_modules/lodash/_cloneDataView.js"),
+    cloneRegExp = __webpack_require__(/*! ./_cloneRegExp */ "../../node_modules/lodash/_cloneRegExp.js"),
+    cloneSymbol = __webpack_require__(/*! ./_cloneSymbol */ "../../node_modules/lodash/_cloneSymbol.js"),
+    cloneTypedArray = __webpack_require__(/*! ./_cloneTypedArray */ "../../node_modules/lodash/_cloneTypedArray.js");
+
+/** `Object#toString` result references. */
+var boolTag = '[object Boolean]',
+    dateTag = '[object Date]',
+    mapTag = '[object Map]',
+    numberTag = '[object Number]',
+    regexpTag = '[object RegExp]',
+    setTag = '[object Set]',
+    stringTag = '[object String]',
+    symbolTag = '[object Symbol]';
+
+var arrayBufferTag = '[object ArrayBuffer]',
+    dataViewTag = '[object DataView]',
+    float32Tag = '[object Float32Array]',
+    float64Tag = '[object Float64Array]',
+    int8Tag = '[object Int8Array]',
+    int16Tag = '[object Int16Array]',
+    int32Tag = '[object Int32Array]',
+    uint8Tag = '[object Uint8Array]',
+    uint8ClampedTag = '[object Uint8ClampedArray]',
+    uint16Tag = '[object Uint16Array]',
+    uint32Tag = '[object Uint32Array]';
+
+/**
+ * Initializes an object clone based on its `toStringTag`.
+ *
+ * **Note:** This function only supports cloning values with tags of
+ * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`.
+ *
+ * @private
+ * @param {Object} object The object to clone.
+ * @param {string} tag The `toStringTag` of the object to clone.
+ * @param {boolean} [isDeep] Specify a deep clone.
+ * @returns {Object} Returns the initialized clone.
+ */
+function initCloneByTag(object, tag, isDeep) {
+  var Ctor = object.constructor;
+  switch (tag) {
+    case arrayBufferTag:
+      return cloneArrayBuffer(object);
+
+    case boolTag:
+    case dateTag:
+      return new Ctor(+object);
+
+    case dataViewTag:
+      return cloneDataView(object, isDeep);
+
+    case float32Tag: case float64Tag:
+    case int8Tag: case int16Tag: case int32Tag:
+    case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:
+      return cloneTypedArray(object, isDeep);
+
+    case mapTag:
+      return new Ctor;
+
+    case numberTag:
+    case stringTag:
+      return new Ctor(object);
+
+    case regexpTag:
+      return cloneRegExp(object);
+
+    case setTag:
+      return new Ctor;
+
+    case symbolTag:
+      return cloneSymbol(object);
+  }
+}
+
+module.exports = initCloneByTag;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_initCloneObject.js":
+/*!*****************************************************!*\
+  !*** ../../node_modules/lodash/_initCloneObject.js ***!
+  \*****************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var baseCreate = __webpack_require__(/*! ./_baseCreate */ "../../node_modules/lodash/_baseCreate.js"),
+    getPrototype = __webpack_require__(/*! ./_getPrototype */ "../../node_modules/lodash/_getPrototype.js"),
+    isPrototype = __webpack_require__(/*! ./_isPrototype */ "../../node_modules/lodash/_isPrototype.js");
+
+/**
+ * Initializes an object clone.
+ *
+ * @private
+ * @param {Object} object The object to clone.
+ * @returns {Object} Returns the initialized clone.
+ */
+function initCloneObject(object) {
+  return (typeof object.constructor == 'function' && !isPrototype(object))
+    ? baseCreate(getPrototype(object))
+    : {};
+}
+
+module.exports = initCloneObject;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_isIndex.js":
+/*!*********************************************!*\
+  !*** ../../node_modules/lodash/_isIndex.js ***!
+  \*********************************************/
+/***/ ((module) => {
+
+/** Used as references for various `Number` constants. */
+var MAX_SAFE_INTEGER = 9007199254740991;
+
+/** Used to detect unsigned integer values. */
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+
+/**
+ * Checks if `value` is a valid array-like index.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
+ * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
+ */
+function isIndex(value, length) {
+  var type = typeof value;
+  length = length == null ? MAX_SAFE_INTEGER : length;
+
+  return !!length &&
+    (type == 'number' ||
+      (type != 'symbol' && reIsUint.test(value))) &&
+        (value > -1 && value % 1 == 0 && value < length);
+}
+
+module.exports = isIndex;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_isKeyable.js":
+/*!***********************************************!*\
+  !*** ../../node_modules/lodash/_isKeyable.js ***!
+  \***********************************************/
+/***/ ((module) => {
+
+/**
+ * Checks if `value` is suitable for use as unique object key.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
+ */
+function isKeyable(value) {
+  var type = typeof value;
+  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
+    ? (value !== '__proto__')
+    : (value === null);
+}
+
+module.exports = isKeyable;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_isMasked.js":
+/*!**********************************************!*\
+  !*** ../../node_modules/lodash/_isMasked.js ***!
+  \**********************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var coreJsData = __webpack_require__(/*! ./_coreJsData */ "../../node_modules/lodash/_coreJsData.js");
+
+/** Used to detect methods masquerading as native. */
+var maskSrcKey = (function() {
+  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
+  return uid ? ('Symbol(src)_1.' + uid) : '';
+}());
+
+/**
+ * Checks if `func` has its source masked.
+ *
+ * @private
+ * @param {Function} func The function to check.
+ * @returns {boolean} Returns `true` if `func` is masked, else `false`.
+ */
+function isMasked(func) {
+  return !!maskSrcKey && (maskSrcKey in func);
+}
+
+module.exports = isMasked;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_isPrototype.js":
+/*!*************************************************!*\
+  !*** ../../node_modules/lodash/_isPrototype.js ***!
+  \*************************************************/
+/***/ ((module) => {
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/**
+ * Checks if `value` is likely a prototype object.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
+ */
+function isPrototype(value) {
+  var Ctor = value && value.constructor,
+      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;
+
+  return value === proto;
+}
+
+module.exports = isPrototype;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_listCacheClear.js":
+/*!****************************************************!*\
+  !*** ../../node_modules/lodash/_listCacheClear.js ***!
+  \****************************************************/
+/***/ ((module) => {
+
+/**
+ * Removes all key-value entries from the list cache.
+ *
+ * @private
+ * @name clear
+ * @memberOf ListCache
+ */
+function listCacheClear() {
+  this.__data__ = [];
+  this.size = 0;
+}
+
+module.exports = listCacheClear;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_listCacheDelete.js":
+/*!*****************************************************!*\
+  !*** ../../node_modules/lodash/_listCacheDelete.js ***!
+  \*****************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var assocIndexOf = __webpack_require__(/*! ./_assocIndexOf */ "../../node_modules/lodash/_assocIndexOf.js");
+
+/** Used for built-in method references. */
+var arrayProto = Array.prototype;
+
+/** Built-in value references. */
+var splice = arrayProto.splice;
+
+/**
+ * Removes `key` and its value from the list cache.
+ *
+ * @private
+ * @name delete
+ * @memberOf ListCache
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function listCacheDelete(key) {
+  var data = this.__data__,
+      index = assocIndexOf(data, key);
+
+  if (index < 0) {
+    return false;
+  }
+  var lastIndex = data.length - 1;
+  if (index == lastIndex) {
+    data.pop();
+  } else {
+    splice.call(data, index, 1);
+  }
+  --this.size;
+  return true;
+}
+
+module.exports = listCacheDelete;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_listCacheGet.js":
+/*!**************************************************!*\
+  !*** ../../node_modules/lodash/_listCacheGet.js ***!
+  \**************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var assocIndexOf = __webpack_require__(/*! ./_assocIndexOf */ "../../node_modules/lodash/_assocIndexOf.js");
+
+/**
+ * Gets the list cache value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf ListCache
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function listCacheGet(key) {
+  var data = this.__data__,
+      index = assocIndexOf(data, key);
+
+  return index < 0 ? undefined : data[index][1];
+}
+
+module.exports = listCacheGet;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_listCacheHas.js":
+/*!**************************************************!*\
+  !*** ../../node_modules/lodash/_listCacheHas.js ***!
+  \**************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var assocIndexOf = __webpack_require__(/*! ./_assocIndexOf */ "../../node_modules/lodash/_assocIndexOf.js");
+
+/**
+ * Checks if a list cache value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf ListCache
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function listCacheHas(key) {
+  return assocIndexOf(this.__data__, key) > -1;
+}
+
+module.exports = listCacheHas;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_listCacheSet.js":
+/*!**************************************************!*\
+  !*** ../../node_modules/lodash/_listCacheSet.js ***!
+  \**************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var assocIndexOf = __webpack_require__(/*! ./_assocIndexOf */ "../../node_modules/lodash/_assocIndexOf.js");
+
+/**
+ * Sets the list cache `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf ListCache
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the list cache instance.
+ */
+function listCacheSet(key, value) {
+  var data = this.__data__,
+      index = assocIndexOf(data, key);
+
+  if (index < 0) {
+    ++this.size;
+    data.push([key, value]);
+  } else {
+    data[index][1] = value;
+  }
+  return this;
+}
+
+module.exports = listCacheSet;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_mapCacheClear.js":
+/*!***************************************************!*\
+  !*** ../../node_modules/lodash/_mapCacheClear.js ***!
+  \***************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var Hash = __webpack_require__(/*! ./_Hash */ "../../node_modules/lodash/_Hash.js"),
+    ListCache = __webpack_require__(/*! ./_ListCache */ "../../node_modules/lodash/_ListCache.js"),
+    Map = __webpack_require__(/*! ./_Map */ "../../node_modules/lodash/_Map.js");
+
+/**
+ * Removes all key-value entries from the map.
+ *
+ * @private
+ * @name clear
+ * @memberOf MapCache
+ */
+function mapCacheClear() {
+  this.size = 0;
+  this.__data__ = {
+    'hash': new Hash,
+    'map': new (Map || ListCache),
+    'string': new Hash
+  };
+}
+
+module.exports = mapCacheClear;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_mapCacheDelete.js":
+/*!****************************************************!*\
+  !*** ../../node_modules/lodash/_mapCacheDelete.js ***!
+  \****************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var getMapData = __webpack_require__(/*! ./_getMapData */ "../../node_modules/lodash/_getMapData.js");
+
+/**
+ * Removes `key` and its value from the map.
+ *
+ * @private
+ * @name delete
+ * @memberOf MapCache
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function mapCacheDelete(key) {
+  var result = getMapData(this, key)['delete'](key);
+  this.size -= result ? 1 : 0;
+  return result;
+}
+
+module.exports = mapCacheDelete;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_mapCacheGet.js":
+/*!*************************************************!*\
+  !*** ../../node_modules/lodash/_mapCacheGet.js ***!
+  \*************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var getMapData = __webpack_require__(/*! ./_getMapData */ "../../node_modules/lodash/_getMapData.js");
+
+/**
+ * Gets the map value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf MapCache
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function mapCacheGet(key) {
+  return getMapData(this, key).get(key);
+}
+
+module.exports = mapCacheGet;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_mapCacheHas.js":
+/*!*************************************************!*\
+  !*** ../../node_modules/lodash/_mapCacheHas.js ***!
+  \*************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var getMapData = __webpack_require__(/*! ./_getMapData */ "../../node_modules/lodash/_getMapData.js");
+
+/**
+ * Checks if a map value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf MapCache
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function mapCacheHas(key) {
+  return getMapData(this, key).has(key);
+}
+
+module.exports = mapCacheHas;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_mapCacheSet.js":
+/*!*************************************************!*\
+  !*** ../../node_modules/lodash/_mapCacheSet.js ***!
+  \*************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var getMapData = __webpack_require__(/*! ./_getMapData */ "../../node_modules/lodash/_getMapData.js");
+
+/**
+ * Sets the map `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf MapCache
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the map cache instance.
+ */
+function mapCacheSet(key, value) {
+  var data = getMapData(this, key),
+      size = data.size;
+
+  data.set(key, value);
+  this.size += data.size == size ? 0 : 1;
+  return this;
+}
+
+module.exports = mapCacheSet;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_mapToArray.js":
+/*!************************************************!*\
+  !*** ../../node_modules/lodash/_mapToArray.js ***!
+  \************************************************/
+/***/ ((module) => {
+
+/**
+ * Converts `map` to its key-value pairs.
+ *
+ * @private
+ * @param {Object} map The map to convert.
+ * @returns {Array} Returns the key-value pairs.
+ */
+function mapToArray(map) {
+  var index = -1,
+      result = Array(map.size);
+
+  map.forEach(function(value, key) {
+    result[++index] = [key, value];
+  });
+  return result;
+}
+
+module.exports = mapToArray;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_nativeCreate.js":
+/*!**************************************************!*\
+  !*** ../../node_modules/lodash/_nativeCreate.js ***!
+  \**************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var getNative = __webpack_require__(/*! ./_getNative */ "../../node_modules/lodash/_getNative.js");
+
+/* Built-in method references that are verified to be native. */
+var nativeCreate = getNative(Object, 'create');
+
+module.exports = nativeCreate;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_nativeKeys.js":
+/*!************************************************!*\
+  !*** ../../node_modules/lodash/_nativeKeys.js ***!
+  \************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var overArg = __webpack_require__(/*! ./_overArg */ "../../node_modules/lodash/_overArg.js");
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeKeys = overArg(Object.keys, Object);
+
+module.exports = nativeKeys;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_nativeKeysIn.js":
+/*!**************************************************!*\
+  !*** ../../node_modules/lodash/_nativeKeysIn.js ***!
+  \**************************************************/
+/***/ ((module) => {
+
+/**
+ * This function is like
+ * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
+ * except that it includes inherited enumerable properties.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ */
+function nativeKeysIn(object) {
+  var result = [];
+  if (object != null) {
+    for (var key in Object(object)) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+
+module.exports = nativeKeysIn;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_nodeUtil.js":
+/*!**********************************************!*\
+  !*** ../../node_modules/lodash/_nodeUtil.js ***!
+  \**********************************************/
+/***/ ((module, exports, __webpack_require__) => {
+
+/* module decorator */ module = __webpack_require__.nmd(module);
+var freeGlobal = __webpack_require__(/*! ./_freeGlobal */ "../../node_modules/lodash/_freeGlobal.js");
+
+/** Detect free variable `exports`. */
+var freeExports =  true && exports && !exports.nodeType && exports;
+
+/** Detect free variable `module`. */
+var freeModule = freeExports && "object" == 'object' && module && !module.nodeType && module;
+
+/** Detect the popular CommonJS extension `module.exports`. */
+var moduleExports = freeModule && freeModule.exports === freeExports;
+
+/** Detect free variable `process` from Node.js. */
+var freeProcess = moduleExports && freeGlobal.process;
+
+/** Used to access faster Node.js helpers. */
+var nodeUtil = (function() {
+  try {
+    // Use `util.types` for Node.js 10+.
+    var types = freeModule && freeModule.require && freeModule.require('util').types;
+
+    if (types) {
+      return types;
+    }
+
+    // Legacy `process.binding('util')` for Node.js < 10.
+    return freeProcess && freeProcess.binding && freeProcess.binding('util');
+  } catch (e) {}
+}());
+
+module.exports = nodeUtil;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_objectToString.js":
+/*!****************************************************!*\
+  !*** ../../node_modules/lodash/_objectToString.js ***!
+  \****************************************************/
+/***/ ((module) => {
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var nativeObjectToString = objectProto.toString;
+
+/**
+ * Converts `value` to a string using `Object.prototype.toString`.
+ *
+ * @private
+ * @param {*} value The value to convert.
+ * @returns {string} Returns the converted string.
+ */
+function objectToString(value) {
+  return nativeObjectToString.call(value);
+}
+
+module.exports = objectToString;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_overArg.js":
+/*!*********************************************!*\
+  !*** ../../node_modules/lodash/_overArg.js ***!
+  \*********************************************/
+/***/ ((module) => {
+
+/**
+ * Creates a unary function that invokes `func` with its argument transformed.
+ *
+ * @private
+ * @param {Function} func The function to wrap.
+ * @param {Function} transform The argument transform.
+ * @returns {Function} Returns the new function.
+ */
+function overArg(func, transform) {
+  return function(arg) {
+    return func(transform(arg));
+  };
+}
+
+module.exports = overArg;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_root.js":
+/*!******************************************!*\
+  !*** ../../node_modules/lodash/_root.js ***!
+  \******************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var freeGlobal = __webpack_require__(/*! ./_freeGlobal */ "../../node_modules/lodash/_freeGlobal.js");
+
+/** Detect free variable `self`. */
+var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+
+/** Used as a reference to the global object. */
+var root = freeGlobal || freeSelf || Function('return this')();
+
+module.exports = root;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_setCacheAdd.js":
+/*!*************************************************!*\
+  !*** ../../node_modules/lodash/_setCacheAdd.js ***!
+  \*************************************************/
+/***/ ((module) => {
+
+/** Used to stand-in for `undefined` hash values. */
+var HASH_UNDEFINED = '__lodash_hash_undefined__';
+
+/**
+ * Adds `value` to the array cache.
+ *
+ * @private
+ * @name add
+ * @memberOf SetCache
+ * @alias push
+ * @param {*} value The value to cache.
+ * @returns {Object} Returns the cache instance.
+ */
+function setCacheAdd(value) {
+  this.__data__.set(value, HASH_UNDEFINED);
+  return this;
+}
+
+module.exports = setCacheAdd;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_setCacheHas.js":
+/*!*************************************************!*\
+  !*** ../../node_modules/lodash/_setCacheHas.js ***!
+  \*************************************************/
+/***/ ((module) => {
+
+/**
+ * Checks if `value` is in the array cache.
+ *
+ * @private
+ * @name has
+ * @memberOf SetCache
+ * @param {*} value The value to search for.
+ * @returns {number} Returns `true` if `value` is found, else `false`.
+ */
+function setCacheHas(value) {
+  return this.__data__.has(value);
+}
+
+module.exports = setCacheHas;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_setToArray.js":
+/*!************************************************!*\
+  !*** ../../node_modules/lodash/_setToArray.js ***!
+  \************************************************/
+/***/ ((module) => {
+
+/**
+ * Converts `set` to an array of its values.
+ *
+ * @private
+ * @param {Object} set The set to convert.
+ * @returns {Array} Returns the values.
+ */
+function setToArray(set) {
+  var index = -1,
+      result = Array(set.size);
+
+  set.forEach(function(value) {
+    result[++index] = value;
+  });
+  return result;
+}
+
+module.exports = setToArray;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_stackClear.js":
+/*!************************************************!*\
+  !*** ../../node_modules/lodash/_stackClear.js ***!
+  \************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var ListCache = __webpack_require__(/*! ./_ListCache */ "../../node_modules/lodash/_ListCache.js");
+
+/**
+ * Removes all key-value entries from the stack.
+ *
+ * @private
+ * @name clear
+ * @memberOf Stack
+ */
+function stackClear() {
+  this.__data__ = new ListCache;
+  this.size = 0;
+}
+
+module.exports = stackClear;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_stackDelete.js":
+/*!*************************************************!*\
+  !*** ../../node_modules/lodash/_stackDelete.js ***!
+  \*************************************************/
+/***/ ((module) => {
+
+/**
+ * Removes `key` and its value from the stack.
+ *
+ * @private
+ * @name delete
+ * @memberOf Stack
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function stackDelete(key) {
+  var data = this.__data__,
+      result = data['delete'](key);
+
+  this.size = data.size;
+  return result;
+}
+
+module.exports = stackDelete;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_stackGet.js":
+/*!**********************************************!*\
+  !*** ../../node_modules/lodash/_stackGet.js ***!
+  \**********************************************/
+/***/ ((module) => {
+
+/**
+ * Gets the stack value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf Stack
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function stackGet(key) {
+  return this.__data__.get(key);
+}
+
+module.exports = stackGet;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_stackHas.js":
+/*!**********************************************!*\
+  !*** ../../node_modules/lodash/_stackHas.js ***!
+  \**********************************************/
+/***/ ((module) => {
+
+/**
+ * Checks if a stack value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf Stack
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function stackHas(key) {
+  return this.__data__.has(key);
+}
+
+module.exports = stackHas;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_stackSet.js":
+/*!**********************************************!*\
+  !*** ../../node_modules/lodash/_stackSet.js ***!
+  \**********************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var ListCache = __webpack_require__(/*! ./_ListCache */ "../../node_modules/lodash/_ListCache.js"),
+    Map = __webpack_require__(/*! ./_Map */ "../../node_modules/lodash/_Map.js"),
+    MapCache = __webpack_require__(/*! ./_MapCache */ "../../node_modules/lodash/_MapCache.js");
+
+/** Used as the size to enable large array optimizations. */
+var LARGE_ARRAY_SIZE = 200;
+
+/**
+ * Sets the stack `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf Stack
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the stack cache instance.
+ */
+function stackSet(key, value) {
+  var data = this.__data__;
+  if (data instanceof ListCache) {
+    var pairs = data.__data__;
+    if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
+      pairs.push([key, value]);
+      this.size = ++data.size;
+      return this;
+    }
+    data = this.__data__ = new MapCache(pairs);
+  }
+  data.set(key, value);
+  this.size = data.size;
+  return this;
+}
+
+module.exports = stackSet;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/_toSource.js":
+/*!**********************************************!*\
+  !*** ../../node_modules/lodash/_toSource.js ***!
+  \**********************************************/
+/***/ ((module) => {
+
+/** Used for built-in method references. */
+var funcProto = Function.prototype;
+
+/** Used to resolve the decompiled source of functions. */
+var funcToString = funcProto.toString;
+
+/**
+ * Converts `func` to its source code.
+ *
+ * @private
+ * @param {Function} func The function to convert.
+ * @returns {string} Returns the source code.
+ */
+function toSource(func) {
+  if (func != null) {
+    try {
+      return funcToString.call(func);
+    } catch (e) {}
+    try {
+      return (func + '');
+    } catch (e) {}
+  }
+  return '';
+}
+
+module.exports = toSource;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/cloneDeep.js":
+/*!**********************************************!*\
+  !*** ../../node_modules/lodash/cloneDeep.js ***!
+  \**********************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var baseClone = __webpack_require__(/*! ./_baseClone */ "../../node_modules/lodash/_baseClone.js");
+
+/** Used to compose bitmasks for cloning. */
+var CLONE_DEEP_FLAG = 1,
+    CLONE_SYMBOLS_FLAG = 4;
+
+/**
+ * This method is like `_.clone` except that it recursively clones `value`.
+ *
+ * @static
+ * @memberOf _
+ * @since 1.0.0
+ * @category Lang
+ * @param {*} value The value to recursively clone.
+ * @returns {*} Returns the deep cloned value.
+ * @see _.clone
+ * @example
+ *
+ * var objects = [{ 'a': 1 }, { 'b': 2 }];
+ *
+ * var deep = _.cloneDeep(objects);
+ * console.log(deep[0] === objects[0]);
+ * // => false
+ */
+function cloneDeep(value) {
+  return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);
+}
+
+module.exports = cloneDeep;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/eq.js":
+/*!***************************************!*\
+  !*** ../../node_modules/lodash/eq.js ***!
+  \***************************************/
+/***/ ((module) => {
+
+/**
+ * Performs a
+ * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * comparison between two values to determine if they are equivalent.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ * @example
+ *
+ * var object = { 'a': 1 };
+ * var other = { 'a': 1 };
+ *
+ * _.eq(object, object);
+ * // => true
+ *
+ * _.eq(object, other);
+ * // => false
+ *
+ * _.eq('a', 'a');
+ * // => true
+ *
+ * _.eq('a', Object('a'));
+ * // => false
+ *
+ * _.eq(NaN, NaN);
+ * // => true
+ */
+function eq(value, other) {
+  return value === other || (value !== value && other !== other);
+}
+
+module.exports = eq;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/isArguments.js":
+/*!************************************************!*\
+  !*** ../../node_modules/lodash/isArguments.js ***!
+  \************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var baseIsArguments = __webpack_require__(/*! ./_baseIsArguments */ "../../node_modules/lodash/_baseIsArguments.js"),
+    isObjectLike = __webpack_require__(/*! ./isObjectLike */ "../../node_modules/lodash/isObjectLike.js");
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/** Built-in value references. */
+var propertyIsEnumerable = objectProto.propertyIsEnumerable;
+
+/**
+ * Checks if `value` is likely an `arguments` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+ *  else `false`.
+ * @example
+ *
+ * _.isArguments(function() { return arguments; }());
+ * // => true
+ *
+ * _.isArguments([1, 2, 3]);
+ * // => false
+ */
+var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {
+  return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&
+    !propertyIsEnumerable.call(value, 'callee');
+};
+
+module.exports = isArguments;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/isArray.js":
+/*!********************************************!*\
+  !*** ../../node_modules/lodash/isArray.js ***!
+  \********************************************/
+/***/ ((module) => {
+
+/**
+ * Checks if `value` is classified as an `Array` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an array, else `false`.
+ * @example
+ *
+ * _.isArray([1, 2, 3]);
+ * // => true
+ *
+ * _.isArray(document.body.children);
+ * // => false
+ *
+ * _.isArray('abc');
+ * // => false
+ *
+ * _.isArray(_.noop);
+ * // => false
+ */
+var isArray = Array.isArray;
+
+module.exports = isArray;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/isArrayLike.js":
+/*!************************************************!*\
+  !*** ../../node_modules/lodash/isArrayLike.js ***!
+  \************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var isFunction = __webpack_require__(/*! ./isFunction */ "../../node_modules/lodash/isFunction.js"),
+    isLength = __webpack_require__(/*! ./isLength */ "../../node_modules/lodash/isLength.js");
+
+/**
+ * Checks if `value` is array-like. A value is considered array-like if it's
+ * not a function and has a `value.length` that's an integer greater than or
+ * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
+ * @example
+ *
+ * _.isArrayLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isArrayLike(document.body.children);
+ * // => true
+ *
+ * _.isArrayLike('abc');
+ * // => true
+ *
+ * _.isArrayLike(_.noop);
+ * // => false
+ */
+function isArrayLike(value) {
+  return value != null && isLength(value.length) && !isFunction(value);
+}
+
+module.exports = isArrayLike;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/isBuffer.js":
+/*!*********************************************!*\
+  !*** ../../node_modules/lodash/isBuffer.js ***!
+  \*********************************************/
+/***/ ((module, exports, __webpack_require__) => {
+
+/* module decorator */ module = __webpack_require__.nmd(module);
+var root = __webpack_require__(/*! ./_root */ "../../node_modules/lodash/_root.js"),
+    stubFalse = __webpack_require__(/*! ./stubFalse */ "../../node_modules/lodash/stubFalse.js");
+
+/** Detect free variable `exports`. */
+var freeExports =  true && exports && !exports.nodeType && exports;
+
+/** Detect free variable `module`. */
+var freeModule = freeExports && "object" == 'object' && module && !module.nodeType && module;
+
+/** Detect the popular CommonJS extension `module.exports`. */
+var moduleExports = freeModule && freeModule.exports === freeExports;
+
+/** Built-in value references. */
+var Buffer = moduleExports ? root.Buffer : undefined;
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;
+
+/**
+ * Checks if `value` is a buffer.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.3.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
+ * @example
+ *
+ * _.isBuffer(new Buffer(2));
+ * // => true
+ *
+ * _.isBuffer(new Uint8Array(2));
+ * // => false
+ */
+var isBuffer = nativeIsBuffer || stubFalse;
+
+module.exports = isBuffer;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/isEqual.js":
+/*!********************************************!*\
+  !*** ../../node_modules/lodash/isEqual.js ***!
+  \********************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var baseIsEqual = __webpack_require__(/*! ./_baseIsEqual */ "../../node_modules/lodash/_baseIsEqual.js");
+
+/**
+ * Performs a deep comparison between two values to determine if they are
+ * equivalent.
+ *
+ * **Note:** This method supports comparing arrays, array buffers, booleans,
+ * date objects, error objects, maps, numbers, `Object` objects, regexes,
+ * sets, strings, symbols, and typed arrays. `Object` objects are compared
+ * by their own, not inherited, enumerable properties. Functions and DOM
+ * nodes are compared by strict equality, i.e. `===`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ * @example
+ *
+ * var object = { 'a': 1 };
+ * var other = { 'a': 1 };
+ *
+ * _.isEqual(object, other);
+ * // => true
+ *
+ * object === other;
+ * // => false
+ */
+function isEqual(value, other) {
+  return baseIsEqual(value, other);
+}
+
+module.exports = isEqual;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/isFunction.js":
+/*!***********************************************!*\
+  !*** ../../node_modules/lodash/isFunction.js ***!
+  \***********************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var baseGetTag = __webpack_require__(/*! ./_baseGetTag */ "../../node_modules/lodash/_baseGetTag.js"),
+    isObject = __webpack_require__(/*! ./isObject */ "../../node_modules/lodash/isObject.js");
+
+/** `Object#toString` result references. */
+var asyncTag = '[object AsyncFunction]',
+    funcTag = '[object Function]',
+    genTag = '[object GeneratorFunction]',
+    proxyTag = '[object Proxy]';
+
+/**
+ * Checks if `value` is classified as a `Function` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a function, else `false`.
+ * @example
+ *
+ * _.isFunction(_);
+ * // => true
+ *
+ * _.isFunction(/abc/);
+ * // => false
+ */
+function isFunction(value) {
+  if (!isObject(value)) {
+    return false;
+  }
+  // The use of `Object#toString` avoids issues with the `typeof` operator
+  // in Safari 9 which returns 'object' for typed arrays and other constructors.
+  var tag = baseGetTag(value);
+  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+
+module.exports = isFunction;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/isLength.js":
+/*!*********************************************!*\
+  !*** ../../node_modules/lodash/isLength.js ***!
+  \*********************************************/
+/***/ ((module) => {
+
+/** Used as references for various `Number` constants. */
+var MAX_SAFE_INTEGER = 9007199254740991;
+
+/**
+ * Checks if `value` is a valid array-like length.
+ *
+ * **Note:** This method is loosely based on
+ * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
+ * @example
+ *
+ * _.isLength(3);
+ * // => true
+ *
+ * _.isLength(Number.MIN_VALUE);
+ * // => false
+ *
+ * _.isLength(Infinity);
+ * // => false
+ *
+ * _.isLength('3');
+ * // => false
+ */
+function isLength(value) {
+  return typeof value == 'number' &&
+    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+}
+
+module.exports = isLength;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/isMap.js":
+/*!******************************************!*\
+  !*** ../../node_modules/lodash/isMap.js ***!
+  \******************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var baseIsMap = __webpack_require__(/*! ./_baseIsMap */ "../../node_modules/lodash/_baseIsMap.js"),
+    baseUnary = __webpack_require__(/*! ./_baseUnary */ "../../node_modules/lodash/_baseUnary.js"),
+    nodeUtil = __webpack_require__(/*! ./_nodeUtil */ "../../node_modules/lodash/_nodeUtil.js");
+
+/* Node.js helper references. */
+var nodeIsMap = nodeUtil && nodeUtil.isMap;
+
+/**
+ * Checks if `value` is classified as a `Map` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.3.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a map, else `false`.
+ * @example
+ *
+ * _.isMap(new Map);
+ * // => true
+ *
+ * _.isMap(new WeakMap);
+ * // => false
+ */
+var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;
+
+module.exports = isMap;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/isObject.js":
+/*!*********************************************!*\
+  !*** ../../node_modules/lodash/isObject.js ***!
+  \*********************************************/
+/***/ ((module) => {
+
+/**
+ * Checks if `value` is the
+ * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+ * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+ * @example
+ *
+ * _.isObject({});
+ * // => true
+ *
+ * _.isObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isObject(_.noop);
+ * // => true
+ *
+ * _.isObject(null);
+ * // => false
+ */
+function isObject(value) {
+  var type = typeof value;
+  return value != null && (type == 'object' || type == 'function');
+}
+
+module.exports = isObject;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/isObjectLike.js":
+/*!*************************************************!*\
+  !*** ../../node_modules/lodash/isObjectLike.js ***!
+  \*************************************************/
+/***/ ((module) => {
+
+/**
+ * Checks if `value` is object-like. A value is object-like if it's not `null`
+ * and has a `typeof` result of "object".
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+ * @example
+ *
+ * _.isObjectLike({});
+ * // => true
+ *
+ * _.isObjectLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isObjectLike(_.noop);
+ * // => false
+ *
+ * _.isObjectLike(null);
+ * // => false
+ */
+function isObjectLike(value) {
+  return value != null && typeof value == 'object';
+}
+
+module.exports = isObjectLike;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/isSet.js":
+/*!******************************************!*\
+  !*** ../../node_modules/lodash/isSet.js ***!
+  \******************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var baseIsSet = __webpack_require__(/*! ./_baseIsSet */ "../../node_modules/lodash/_baseIsSet.js"),
+    baseUnary = __webpack_require__(/*! ./_baseUnary */ "../../node_modules/lodash/_baseUnary.js"),
+    nodeUtil = __webpack_require__(/*! ./_nodeUtil */ "../../node_modules/lodash/_nodeUtil.js");
+
+/* Node.js helper references. */
+var nodeIsSet = nodeUtil && nodeUtil.isSet;
+
+/**
+ * Checks if `value` is classified as a `Set` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.3.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a set, else `false`.
+ * @example
+ *
+ * _.isSet(new Set);
+ * // => true
+ *
+ * _.isSet(new WeakSet);
+ * // => false
+ */
+var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;
+
+module.exports = isSet;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/isTypedArray.js":
+/*!*************************************************!*\
+  !*** ../../node_modules/lodash/isTypedArray.js ***!
+  \*************************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var baseIsTypedArray = __webpack_require__(/*! ./_baseIsTypedArray */ "../../node_modules/lodash/_baseIsTypedArray.js"),
+    baseUnary = __webpack_require__(/*! ./_baseUnary */ "../../node_modules/lodash/_baseUnary.js"),
+    nodeUtil = __webpack_require__(/*! ./_nodeUtil */ "../../node_modules/lodash/_nodeUtil.js");
+
+/* Node.js helper references. */
+var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+
+/**
+ * Checks if `value` is classified as a typed array.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+ * @example
+ *
+ * _.isTypedArray(new Uint8Array);
+ * // => true
+ *
+ * _.isTypedArray([]);
+ * // => false
+ */
+var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+
+module.exports = isTypedArray;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/keys.js":
+/*!*****************************************!*\
+  !*** ../../node_modules/lodash/keys.js ***!
+  \*****************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var arrayLikeKeys = __webpack_require__(/*! ./_arrayLikeKeys */ "../../node_modules/lodash/_arrayLikeKeys.js"),
+    baseKeys = __webpack_require__(/*! ./_baseKeys */ "../../node_modules/lodash/_baseKeys.js"),
+    isArrayLike = __webpack_require__(/*! ./isArrayLike */ "../../node_modules/lodash/isArrayLike.js");
+
+/**
+ * Creates an array of the own enumerable property names of `object`.
+ *
+ * **Note:** Non-object values are coerced to objects. See the
+ * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
+ * for more details.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ * @example
+ *
+ * function Foo() {
+ *   this.a = 1;
+ *   this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.keys(new Foo);
+ * // => ['a', 'b'] (iteration order is not guaranteed)
+ *
+ * _.keys('hi');
+ * // => ['0', '1']
+ */
+function keys(object) {
+  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+}
+
+module.exports = keys;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/keysIn.js":
+/*!*******************************************!*\
+  !*** ../../node_modules/lodash/keysIn.js ***!
+  \*******************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var arrayLikeKeys = __webpack_require__(/*! ./_arrayLikeKeys */ "../../node_modules/lodash/_arrayLikeKeys.js"),
+    baseKeysIn = __webpack_require__(/*! ./_baseKeysIn */ "../../node_modules/lodash/_baseKeysIn.js"),
+    isArrayLike = __webpack_require__(/*! ./isArrayLike */ "../../node_modules/lodash/isArrayLike.js");
+
+/**
+ * Creates an array of the own and inherited enumerable property names of `object`.
+ *
+ * **Note:** Non-object values are coerced to objects.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Object
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ * @example
+ *
+ * function Foo() {
+ *   this.a = 1;
+ *   this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.keysIn(new Foo);
+ * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
+ */
+function keysIn(object) {
+  return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
+}
+
+module.exports = keysIn;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/stubArray.js":
+/*!**********************************************!*\
+  !*** ../../node_modules/lodash/stubArray.js ***!
+  \**********************************************/
+/***/ ((module) => {
+
+/**
+ * This method returns a new empty array.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.13.0
+ * @category Util
+ * @returns {Array} Returns the new empty array.
+ * @example
+ *
+ * var arrays = _.times(2, _.stubArray);
+ *
+ * console.log(arrays);
+ * // => [[], []]
+ *
+ * console.log(arrays[0] === arrays[1]);
+ * // => false
+ */
+function stubArray() {
+  return [];
+}
+
+module.exports = stubArray;
+
+
+/***/ }),
+
+/***/ "../../node_modules/lodash/stubFalse.js":
+/*!**********************************************!*\
+  !*** ../../node_modules/lodash/stubFalse.js ***!
+  \**********************************************/
+/***/ ((module) => {
+
+/**
+ * This method returns `false`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.13.0
+ * @category Util
+ * @returns {boolean} Returns `false`.
+ * @example
+ *
+ * _.times(2, _.stubFalse);
+ * // => [false, false]
+ */
+function stubFalse() {
+  return false;
+}
+
+module.exports = stubFalse;
+
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			id: moduleId,
+/******/ 			loaded: false,
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Flag the module as loaded
+/******/ 		module.loaded = true;
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/global */
+/******/ 	(() => {
+/******/ 		__webpack_require__.g = (function() {
+/******/ 			if (typeof globalThis === 'object') return globalThis;
+/******/ 			try {
+/******/ 				return this || new Function('return this')();
+/******/ 			} catch (e) {
+/******/ 				if (typeof window === 'object') return window;
+/******/ 			}
+/******/ 		})();
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/node module decorator */
+/******/ 	(() => {
+/******/ 		__webpack_require__.nmd = (module) => {
+/******/ 			module.paths = [];
+/******/ 			if (!module.children) module.children = [];
+/******/ 			return module;
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry need to be wrapped in an IIFE because it need to be in strict mode.
+(() => {
+"use strict";
+/*!********************************!*\
+  !*** ./client/src/provider.ts ***!
+  \********************************/
+__webpack_require__.r(__webpack_exports__);
+/* harmony import */ var _openfin_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @openfin/core */ "../../node_modules/@openfin/core/out/mock.js");
+
+let fileName;
+let debugLogStr;
+let debugLogFile;
+let opfsLogFile;
+const channelName = `${_openfin_core__WEBPACK_IMPORTED_MODULE_0__.fin.me.identity.uuid}-logger`;
+let channelClient;
+let channelProvider;
+let fileHandle;
+window.addEventListener("DOMContentLoaded", async () => {
+    const platform = _openfin_core__WEBPACK_IMPORTED_MODULE_0__.fin.Platform.getCurrentSync();
+    await platform.once("platform-api-ready", async () => init());
+    _openfin_core__WEBPACK_IMPORTED_MODULE_0__.fin.Platform.init({
+        overrideCallback: async (Provider) => {
+            /**
+             * Override the provider class.
+             */
+            class Override extends Provider {
+            }
+            return new Override();
+        }
+    }).catch(() => { });
+});
+/**
+ * Populates DOM with the UI elements and adds listeners obtaining selected/submitted options.
+ */
+async function init() {
+    const logListElement = document.querySelector("#log-list");
+    if (logListElement) {
+        await createLogDropDown(logListElement);
+        logListElement.addEventListener("change", async (selectionChangeEvent) => {
+            fileName = selectionChangeEvent.target.value;
+        });
+    }
+    const upload = document.querySelector("#upload-form");
+    if (upload) {
+        upload.addEventListener("submit", uploadHandler);
+    }
+    const sendAppLogBtn = document.querySelector("#send-app-log");
+    if (sendAppLogBtn) {
+        sendAppLogBtn.addEventListener("click", sendApplicationLogs);
+    }
+    const sendOPFSLogBtn = document.querySelector("#send-opfs-log");
+    if (sendOPFSLogBtn) {
+        sendOPFSLogBtn.addEventListener("click", sendOPFSLogs);
+    }
+    const consoleLogBtn = document.querySelector("#console-app-log");
+    if (consoleLogBtn) {
+        consoleLogBtn.addEventListener("click", consoleLogMessage);
+    }
+    const channelLogBtn = document.querySelector("#channel-app-log");
+    if (channelLogBtn) {
+        channelLogBtn.addEventListener("click", channelLogMessage);
+    }
+    const clearPreviewBtn = document.querySelector("#clear-preview");
+    if (clearPreviewBtn) {
+        clearPreviewBtn.addEventListener("click", clearPreview);
+    }
+    await setupChannelClientAndService();
+}
+/**
+ * Sets up the Channel Client and Service.
+ */
+async function setupChannelClientAndService() {
+    // if your content is coming from the same domain then you would not need to use the Channel API and can consider alternatives
+    // such as BroadcastChannel API or SharedWorker
+    if (channelClient === undefined && channelProvider === undefined) {
+        // set up the file handler for logging for the service
+        if (fileHandle === undefined) {
+            const root = await navigator.storage.getDirectory();
+            // Create a new file handle.
+            // The name could be date based if you were going to create a new file each day.
+            fileHandle = await root.getFileHandle("log.log", { create: true });
+        }
+        channelProvider = await _openfin_core__WEBPACK_IMPORTED_MODULE_0__.fin.InterApplicationBus.Channel.create(channelName);
+        channelProvider.onConnection((identity, payload) => {
+            if (identity.uuid !== _openfin_core__WEBPACK_IMPORTED_MODULE_0__.fin.me.identity.uuid) {
+                // reject connection
+                throw new Error("Connection rejected. Only the current application can connect to the channel.");
+            }
+            // you can add additional logic to validate the view/window connecting (e.g. to ensure it is only trusted urls that are allowed to log etc)
+        });
+        channelProvider.register("log", async (payload, identity) => {
+            if (identity.uuid !== _openfin_core__WEBPACK_IMPORTED_MODULE_0__.fin.me.identity.uuid) {
+                // reject request to log (this is optional but you might have multiple actions registered and you might allow a connection to the service but not all actions)
+                throw new Error("Log request rejected. Only the current application can log.");
+            }
+            const logPreview = document.querySelector("#preview");
+            try {
+                // you could make this more complex to support log levels etc. For now we just pass a string to the log function
+                // utc timestamp
+                const utcTimestamp = new Date().toISOString();
+                const message = `${utcTimestamp}|${identity.name}|${payload}`;
+                await writeLogToFile(message);
+                if (logPreview) {
+                    logPreview.textContent += `
+Console Logged the following message through Channel API: 
+"${message}"`;
+                }
+            }
+            catch (err) {
+                if (logPreview) {
+                    logPreview.textContent += `
+Error console logging message through Channel API: ${err.message}`;
+                }
+            }
+        });
+        channelClient = await _openfin_core__WEBPACK_IMPORTED_MODULE_0__.fin.InterApplicationBus.Channel.connect(channelName);
+    }
+}
+/**
+ * Write logs to file. This logic could be done in a worker to avoid blocking the main thread.
+ * https://developer.mozilla.org/en-US/docs/Web/API/File_System_API/Origin_private_file_system.
+ * @param logMessage The log message to write to file.
+ */
+async function writeLogToFile(logMessage) {
+    try {
+        if (fileHandle === undefined) {
+            const root = await navigator.storage.getDirectory();
+            // Create a new file handle if it doesn't exist.
+            // The name could be date based if you were going to create a new file each day.
+            fileHandle = await root.getFileHandle("log.log", { create: true });
+        }
+        // Create a writable stream
+        const writableStream = await fileHandle.createWritable({ keepExistingData: true });
+        // Move the write position to the end of the file
+        const fileForSize = await fileHandle.getFile();
+        const size = fileForSize.size;
+        await writableStream.seek(size);
+        // Write the log message to the file
+        if (size === 0) {
+            await writableStream.write(logMessage);
+        }
+        else {
+            await writableStream.write(`\n${logMessage}`);
+        }
+        // Close the file
+        await writableStream.close();
+        console.log("Log written to file successfully.");
+    }
+    catch (err) {
+        console.error("Error writing log to file:", err);
+    }
+}
+/**
+ * Handle uploads.
+ * 1. Creates a FormData object.
+ * 2. Creates a File object from the string of the Runtime debug log file contents.
+ * 3. Populates the FormData object with necessary parameters to be read by the server.
+ * 4. Uploads the created runtime debug log file to a server endpoint.
+ * @param submitEvent The event to handle.
+ */
+async function uploadHandler(submitEvent) {
+    submitEvent.preventDefault();
+    if (!fileName) {
+        fileName = "debug.log";
+    }
+    const formData = new FormData();
+    debugLogStr = await getLogFromName(fileName);
+    debugLogFile = new File([debugLogStr], fileName, { type: "text/plain" });
+    formData.append("file", debugLogFile);
+    formData.append("filename", fileName);
+    formData.append("uuid", _openfin_core__WEBPACK_IMPORTED_MODULE_0__.fin.me.uuid);
+    const logPreview = document.querySelector("#preview");
+    try {
+        const uploadState = await fetch("https://built-on-openfin.github.io/container-starter/dev/john/update-logging-example/use-logging-apis/uploads", {
+            method: "POST",
+            body: formData
+        });
+        const uploadStateJson = await uploadState.json();
+        const uploadStateJsonString = JSON.stringify(uploadStateJson, null, 5);
+        const logs = `${new Date().toLocaleTimeString()}: ${uploadStateJsonString}\n`;
+        if (logPreview) {
+            logPreview.textContent += logs;
+        }
+    }
+    catch (err) {
+        if (logPreview) {
+            logPreview.textContent += `
+Error uploading Runtime Logs: ${err.message}`;
+        }
+    }
+}
+/**
+ * Uploads the OPFS log file to the server.
+ * @returns true if the log file was uploaded successfully, false otherwise.
+ */
+async function uploadOPFSLogHandler() {
+    // read the log file from origin private file system
+    if (fileHandle !== undefined) {
+        try {
+            // read the file from fileHanlde
+            const file = await fileHandle.getFile();
+            const logFileName = file.name;
+            const fileContents = await file.text();
+            opfsLogFile = new File([fileContents], logFileName, { type: "text/plain" });
+            const opfsFormData = new FormData();
+            opfsFormData.append("opfsFile", opfsLogFile);
+            opfsFormData.append("filename", logFileName);
+            opfsFormData.append("uuid", _openfin_core__WEBPACK_IMPORTED_MODULE_0__.fin.me.uuid);
+            const result = await fetch("https://built-on-openfin.github.io/container-starter/dev/john/update-logging-example/use-logging-apis/opfsuploads", {
+                method: "POST",
+                body: opfsFormData
+            });
+            if (result.ok) {
+                // Clear the log file after uploading
+                const writableStream = await fileHandle.createWritable();
+                await writableStream.truncate(0);
+                await writableStream.close();
+                const logPreview = document.querySelector("#preview");
+                const uploadStateJson = await result.json();
+                const uploadStateJsonString = JSON.stringify(uploadStateJson, null, 5);
+                const logs = `${new Date().toLocaleTimeString()}: ${uploadStateJsonString}\n`;
+                if (logPreview) {
+                    logPreview.textContent += logs;
+                }
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            console.error("Error reading log file:", error);
+            return false;
+        }
+    }
+    return false;
+}
+/**
+ * Clears the preview log.
+ */
+function clearPreview() {
+    const logPreview = document.querySelector("#preview");
+    if (logPreview) {
+        logPreview.textContent = "";
+    }
+}
+/**
+ * Sends a message to the OpenFin RVM to send the application logs.
+ */
+async function sendApplicationLogs() {
+    const logPreview = document.querySelector("#preview");
+    try {
+        const appLogResponse = await _openfin_core__WEBPACK_IMPORTED_MODULE_0__.fin.Application.getCurrentSync().sendApplicationLog();
+        if (logPreview) {
+            logPreview.textContent += `
+Uploaded App Logs. Log ID: ${appLogResponse.logId}`;
+        }
+    }
+    catch (err) {
+        if (logPreview) {
+            logPreview.textContent += `
+Error uploading App Logs: ${err.message}`;
+        }
+    }
+}
+/**
+ * Sends opfs logs to the server.
+ */
+async function sendOPFSLogs() {
+    const logPreview = document.querySelector("#preview");
+    try {
+        const success = await uploadOPFSLogHandler();
+        if (logPreview) {
+            logPreview.textContent += `
+Uploaded OPFS Logs. Success: ${success}`;
+        }
+    }
+    catch (err) {
+        if (logPreview) {
+            logPreview.textContent += `
+Error uploading OPFS Logs: ${err.message}`;
+        }
+    }
+}
+/**
+ * Sends a message to console log.
+ */
+async function consoleLogMessage() {
+    const logPreview = document.querySelector("#preview");
+    try {
+        const message = `
+Sending console log message: ${Date.now()}`;
+        console.log(message);
+        if (logPreview) {
+            logPreview.textContent += `
+Console Logged the following message: 
+"${message}"`;
+        }
+    }
+    catch (err) {
+        if (logPreview) {
+            logPreview.textContent += `
+Error console logging message: ${err.message}`;
+        }
+    }
+}
+/**
+ * Sends a message to console log through the Channel API.
+ */
+async function channelLogMessage() {
+    const logPreview = document.querySelector("#preview");
+    try {
+        const message = `
+Sending channel log message: ${Date.now()}`;
+        if (logPreview) {
+            logPreview.textContent += `
+Sending the following message through the Channel API: 
+"${message}"`;
+        }
+        await channelClient.dispatch("log", message);
+    }
+    catch (err) {
+        if (logPreview) {
+            logPreview.textContent += `
+Error sending message through Channel API: ${err.message}`;
+        }
+    }
+}
+/**
+ * Retrieves the runtime debug log from a filename.
+ * @param name file name of the runtime debug log to retrieve.
+ * @returns the log content.
+ */
+async function getLogFromName(name) {
+    const log = await _openfin_core__WEBPACK_IMPORTED_MODULE_0__.fin.System.getLog({ name });
+    return log;
+}
+/**
+ * Creates an HTMLOptionElement for each of the Runtime debug logs.
+ * @param parentElement HTML Element to append the log filename HTMLOptionElement to.
+ */
+async function createLogDropDown(parentElement) {
+    const logList = await _openfin_core__WEBPACK_IMPORTED_MODULE_0__.fin.System.getLogList();
+    for (const log of logList) {
+        const logElement = document.createElement("option");
+        logElement.id = log.date;
+        logElement.textContent = log.name;
+        logElement.value = log.name;
+        parentElement.append(logElement);
+    }
+}
+
+})();
+
+/******/ })()
+;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"provider.bundle.js","mappings":";;;;;;;;;;AAAa;;AAEb,8CAA6C,EAAE,aAAa,EAAC;;AAE7D,iBAAiB,mBAAO,CAAC,mDAAQ;AACjC,mBAAmB,mBAAO,CAAC,gEAAkB;AAC7C,iBAAiB,mBAAO,CAAC,4DAAgB;;AAEzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB;AACxB,KAAK;AACL;AACA,GAAG;AACH,EAAE;AACF;AACA;;AAEA,sHAAsH,qBAAM,mBAAmB,qBAAM;;AAErJ;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;AACA,mDAAmD,0BAA0B;AAC7E,2BAA2B,sBAAsB,qBAAqB,mBAAmB;AACzF;AACA;AACA;AACA;AACA,2DAA2D,cAAc;AACzE;AACA;AACA,UAAU,8BAA8B,KAAK,0BAA0B,oBAAoB,4BAA4B;AACvH,IAAI,0BAA0B,gFAAgF,oCAAoC;AAClJ;AACA,IAAI,0DAA0D,2CAA2C;AACzG,OAAO,oCAAoC,iBAAiB,mCAAmC;AAC/F,IAAI;AACJ;AACA;AACA,6BAA6B,wBAAwB;AACrD;AACA;AACA;AACA,qDAAqD,aAAa;;AAElE;;AAEA;AACA;AACA;AACA;AACA;AACA,8CAA8C,aAAa;;AAE3D;;AAEA;AACA,uDAAuD,kCAAkC;AACzF;AACA;AACA;AACA,2DAA2D,cAAc;AACzE;AACA,yEAAyE,oDAAoD;AAC7H;AACA;AACA;AACA,6DAA6D,aAAa;;AAE1E;;AAEA,+CAA+C,aAAa;;AAE5D;;AAEA;AACA;AACA,oDAAoD,gCAAgC;AACpF;AACA;AACA;AACA,2DAA2D,cAAc;AACzE;AACA,kEAAkE,mDAAmD;AACrH;AACA;AACA;AACA,sDAAsD,aAAa;;AAEnE;;AAEA;AACA;AACA,+CAA+C,uBAAuB;AACtE;AACA;AACA;AACA,2DAA2D,cAAc;AACzE;AACA,qDAAqD,2BAA2B;AAChF,iCAAiC,oDAAoD;AACrF;AACA,IAAI,8BAA8B;AAClC;AACA;AACA;AACA,kDAAkD,aAAa;;AAE/D;;AAEA;AACA,yDAAyD,oBAAoB;AAC7E,uBAAuB,0BAA0B,GAAG,qBAAqB,OAAO,oBAAoB;AACpG;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2DAA2D,cAAc;AACzE;AACA;AACA,UAAU,uCAAuC,GAAG,6BAA6B,OAAO,0BAA0B;AAClH,IAAI,gCAAgC,GAAG,2BAA2B,OAAO,0BAA0B;AACnG,uBAAuB,0BAA0B;AACjD;AACA;AACA;AACA,gDAAgD,aAAa;;AAE7D;;AAEA;AACA,kDAAkD,mBAAmB;AACrE;AACA;AACA;AACA,2DAA2D,cAAc;AACzE;AACA;AACA,UAAU,qBAAqB,GAAG,mBAAmB,kBAAkB,gCAAgC;AACvG,oDAAoD,sBAAsB;AAC1E;AACA,0CAA0C,kCAAkC,GAAG,4CAA4C;AAC3H,QAAQ,mCAAmC;AAC3C;AACA;AACA;AACA,8CAA8C,aAAa;;AAE3D;;AAEA;AACA,0EAA0E,qBAAqB;AAC/F,IAAI,mBAAmB;AACvB;AACA;AACA,kGAAkG,0BAA0B;AAC5H;AACA;AACA;AACA,mDAAmD,aAAa;;AAEhE;;AAEA;AACA,kDAAkD,qBAAqB;AACvE;AACA;AACA;AACA,2DAA2D,cAAc;AACzE;AACA;AACA,UAAU,qBAAqB,GAAG,mBAAmB,kBAAkB,gCAAgC;AACvG,yCAAyC,yBAAyB;AAClE,IAAI;AACJ;AACA,IAAI,qEAAqE;AACzE,IAAI,8BAA8B,6BAA6B,6CAA6C;AAC5G,IAAI,mCAAmC;AACvC;AACA,6BAA6B,yBAAyB,qCAAqC;AAC3F;AACA;AACA;AACA;AACA,gDAAgD,aAAa;;AAE7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,0BAA0B,GAAG;AACnC,MAAM,kCAAkC,GAAG;AAC3C,MAAM,oBAAoB,GAAG;AAC7B,MAAM,2BAA2B,GAAG;AACpC,MAAM,uBAAuB,GAAG;AAChC,MAAM,qBAAqB,GAAG;AAC9B,MAAM,mBAAmB,GAAG;AAC5B,MAAM,qBAAqB,GAAG;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU,2BAA2B;AACrC,MAAM,+BAA+B,uCAAuC,2BAA2B;AACvG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,oCAAoC;AACnD;AACA;AACA,CAAC;AACD;AACA;AACA,CAAC;AACD;AACA,0CAA0C,4BAA4B;AACtE,CAAC;AACD;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C,aAAa;AAC3D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,iDAAiD,aAAa;AAC9D,kFAAkF,wBAAwB;AAC1G,+DAA+D,kBAAkB;AACjF,8CAA8C,yBAAyB;AACvE,sDAAsD,yBAAyB,KAAK,uBAAuB;AAC3G;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,oCAAoC;AACpD;AACA;AACA,EAAE;AACF;AACA;AACA,EAAE;AACF;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA,EAAE;;AAEF;;AAEA;AACA;AACA;AACA,CAAC;;AAED;;AAEA;;AAEA;;AAEA;;AAEA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4CAA4C,aAAa;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,oBAAoB,IAAI,qBAAqB;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mEAAmE;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qEAAqE;AACrE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,sBAAsB;AAC5E;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,sBAAsB;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,sDAAsD,sBAAsB;AAC5E;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,sBAAsB;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B;AAC/B;AACA;AACA;AACA;AACA,4BAA4B,cAAc;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,uDAAuD,aAAa;AACpE;AACA;AACA;AACA,yDAAyD,WAAW;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,gCAAgC;AAChD;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD;AACrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,kBAAkB;AACzC;AACA,kCAAkC,oBAAoB;AACtD;AACA;AACA;AACA;AACA;AACA,gBAAgB,gBAAgB;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA,qEAAqE,YAAY;AACjF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B;AAC5B,cAAc;AACd;AACA;AACA,yDAAyD,kBAAkB;AAC3E;AACA,gCAAgC,0BAA0B;AAC1D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,4CAA4C;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yCAAyC,wCAAwC;AACjF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,iBAAiB,aAAa;AAC9B,4BAA4B,YAAY;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,iBAAiB,aAAa;AAC9B,gCAAgC,YAAY;AAC5C;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA,4CAA4C,aAAa;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA,mDAAmD,aAAa;AAChE;AACA;AACA,mCAAmC,gBAAgB;AACnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,KAAK;AAClB;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gEAAgE,iBAAiB;AACjF,4DAA4D;AAC5D;AACA;AACA;AACA;AACA,qCAAqC,0BAA0B;AAC/D;AACA;;AAEA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+EAA+E,cAAc;AAC7F;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA,wDAAwD,aAAa;AACrE;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,KAAK;AACzB,oBAAoB,QAAQ,0CAA0C,GAAG;AACzE;AACA;AACA;AACA,oBAAoB,SAAS;AAC7B,mDAAmD,MAAM;AACzD;AACA;AACA;AACA;AACA;;AAEA;;AAEA,uDAAuD,aAAa;AACpE;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,qBAAqB;AACzC,oBAAoB,KAAK;AACzB,8BAA8B,GAAG,GAAG,uBAAuB;AAC3D,yEAAyE,MAAM;AAC/E;AACA,aAAa;AACb,qBAAqB;AACrB;AACA,mCAAmC,IAAI;AACvC,uCAAuC,GAAG;AAC1C,yEAAyE,OAAO;AAChF;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,gBAAgB,oCAAoC;AACpD;AACA;AACA,EAAE;AACF;AACA;AACA,EAAE;AACF;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA,EAAE;;AAEF;AACA;AACA;AACA;AACA;AACA,gBAAgB,oCAAoC;AACpD;AACA;AACA,EAAE;AACF;AACA;AACA,EAAE;AACF;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA,EAAE;;AAEF;AACA;AACA;AACA;AACA;AACA,gBAAgB,oCAAoC;AACpD;AACA;AACA,EAAE;AACF;AACA;AACA,EAAE;AACF;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA,EAAE;;AAEF;;AAEA,uDAAuD,aAAa;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,QAAQ,MAAM,yBAAyB;AAC7E;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA,8CAA8C,QAAQ;AACtD;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,aAAa;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,gCAAgC;AAC9D,qBAAqB,gBAAgB,KAAK,mBAAmB;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gDAAgD,OAAO;AACvD;AACA;AACA;AACA;AACA;AACA,0DAA0D,aAAa;AACvE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C,OAAO;AACpD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,+CAA+C;AAChE,iBAAiB,iEAAiE;AAClF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA,+EAA+E,mBAAmB;AAClG;AACA,wEAAwE,mBAAmB;AAC3F,kEAAkE,iBAAiB;AACnF;AACA;AACA;AACA;AACA;AACA;AACA,0CAA0C,yBAAyB;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yCAAyC,oBAAoB,2BAA2B,mBAAmB;AAC3G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC,4BAA4B;AAChE;AACA;AACA;AACA,+BAA+B,4BAA4B;AAC3D;AACA;AACA;AACA,wFAAwF,UAAU;AAClG,8BAA8B,kBAAkB;AAChD;AACA;AACA,YAAY,iBAAiB;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wEAAwE,2BAA2B;AACnG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B;AAC1B;AACA;AACA;AACA,4FAA4F,gBAAgB,KAAK,kBAAkB;AACnI;AACA;AACA;AACA,4DAA4D,eAAe;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,gBAAgB;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yCAAyC,cAAc;AACvD;AACA;AACA;AACA;AACA;AACA,2CAA2C,eAAe;AAC1D;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC,iCAAiC;AACxE;AACA,2BAA2B,gBAAgB;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4DAA4D,gDAAgD;AAC5G,mEAAmE,oBAAoB;AACvF,wBAAwB,gBAAgB;AACxC,2DAA2D,8CAA8C,IAAI,UAAU;AACvH,kEAAkE,mBAAmB;AACrF;AACA;AACA;AACA,gDAAgD,UAAU;AAC1D;AACA,qCAAqC,eAAe;AACpD;AACA;AACA;AACA;AACA;AACA,2BAA2B,gBAAgB;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4DAA4D,gDAAgD;AAC5G;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC,gBAAgB;AACxD;AACA;AACA,2BAA2B,gBAAgB;AAC3C;AACA;AACA;AACA;AACA,kDAAkD,iCAAiC;AACnF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C,qBAAqB;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,wDAAwD,aAAa;AACrE;AACA;AACA;AACA;;AAEA;;AAEA,4CAA4C,aAAa;AACzD;AACA;AACA;AACA;AACA,4CAA4C,4CAA4C;AACxF,0CAA0C,4CAA4C;AACtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,sDAAsD,2BAA2B,UAAU,SAAS;AACpG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C,gCAAgC;AAC7E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA;AACA,0DAA0D,wBAAwB;AAClF,qBAAqB,SAAS;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,6EAA6E,SAAS;AACtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,wDAAwD,yBAAyB;AACjF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB;AACxB,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,yDAAyD,uBAAuB;AAChF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C,uCAAuC;AACrF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+CAA+C,kCAAkC;AACjF;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,8DAA8D,kBAAkB;AAChF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,gEAAgE,kBAAkB;AAClF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C,uCAAuC;AACrF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+CAA+C,kCAAkC;AACjF;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,gEAAgE,kBAAkB;AAClF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oDAAoD;AACpD;AACA;AACA;AACA;AACA;AACA,oBAAoB,kDAAkD;AACtE;AACA,QAAQ;AACR;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA,sBAAsB;AACtB,+CAA+C,2BAA2B;AAC1E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA;AACA,0CAA0C,uCAAuC;AACjF,qBAAqB,SAAS;AAC9B;AACA;AACA,eAAe,kCAAkC;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ,QAAQ;AACR;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ,QAAQ;AACR;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,2DAA2D,0BAA0B;AACrF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB,YAAY;AACZ;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB,YAAY;AACZ;AACA;AACA,YAAY;AACZ;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,sDAAsD,kBAAkB,UAAU,SAAS;AAC3F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA,kBAAkB,mBAAmB,IAAI,wBAAwB;AACjE,qDAAqD,oCAAoC;AACzF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,gBAAgB,WAAW,SAAS;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB;AACxB,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,iFAAiF,SAAS;AAC1F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB;AACxB,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,8DAA8D,kBAAkB;AAChF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB;AACxB,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,oEAAoE,4BAA4B;AAChG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB;AACxB,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,+DAA+D,kBAAkB;AACjF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA,eAAe,aAAa;AAC5B,eAAe,MAAM;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA,6DAA6D,sBAAsB,KAAK,mBAAmB;AAC3G;AACA,QAAQ,gDAAgD;AACxD;AACA;AACA,gCAAgC,gBAAgB;AAChD;AACA,SAAS;AACT;AACA,2CAA2C,WAAW;AACtD;AACA,mEAAmE,yCAAyC;AAC5G;AACA;AACA;AACA,2FAA2F,MAAM;AACjG;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,4BAA4B;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,SAAS;AACT,gBAAgB,QAAQ,oCAAoC;AAC5D;AACA;AACA;AACA;AACA;AACA,oBAAoB,2BAA2B;AAC/C;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,UAAU;AAC1B;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mDAAmD,aAAa;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,8CAA8C;AACpF;AACA;AACA,sDAAsD,sCAAsC;AAC5F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yDAAyD,0BAA0B;AACnF;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C,oCAAoC;AACjF;AACA;AACA;AACA;AACA;AACA,0DAA0D,kBAAkB;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uDAAuD,kBAAkB;AACzE;AACA;AACA;AACA;AACA;AACA;AACA,cAAc,iBAAiB;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kDAAkD;AAClD,0DAA0D,mCAAmC;AAC7F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iEAAiE,kBAAkB;AACnF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uDAAuD,kBAAkB;AACzE;AACA;AACA;AACA;AACA;AACA,cAAc,iBAAiB;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,0BAA0B;AACvF;AACA;AACA;AACA;AACA;AACA,cAAc,iBAAiB;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA,yEAAyE,kBAAkB;AAC3F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uEAAuE,kBAAkB;AACzF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8DAA8D,kBAAkB;AAChF;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2CAA2C,oDAAoD;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+DAA+D,kBAAkB,UAAU,SAAS;AACpG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qCAAqC;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,2BAA2B;AAC7F;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C,oCAAoC;AACjF;AACA;AACA,gDAAgD;AAChD;AACA;AACA;AACA;AACA,qBAAqB,WAAW,SAAS,kDAAkD,kBAAkB;AAC7G;AACA;AACA;AACA,mCAAmC,wBAAwB;AAC3D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0CAA0C,cAAc;AACxD;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,wDAAwD;AACrH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mFAAmF,kBAAkB;AACrG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yCAAyC,oCAAoC;AAC7E;AACA;AACA;AACA;AACA;AACA,mBAAmB,mBAAmB,IAAI,wBAAwB;AAClE;AACA;AACA,6BAA6B,kBAAkB;AAC/C;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,oCAAoC;AACrD;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA;AACA,iDAAiD,aAAa;AAC9D;AACA;AACA;AACA,QAAQ,kBAAkB;AAC1B,QAAQ,YAAY;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;;AAEA;;AAEA;AACA;AACA;AACA,mDAAmD,aAAa;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,mDAAmD;AAChH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8EAA8E,QAAQ;AACtF;AACA;AACA;AACA,sFAAsF,SAAS;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oEAAoE,IAAI,8BAA8B,GAAG,8BAA8B;AACvI,oDAAoD,aAAa;AACjE;AACA,oEAAoE,IAAI,8BAA8B;AACtG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iEAAiE,yBAAyB;AAC1F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+DAA+D,yBAAyB;AACxF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iFAAiF,SAAS;AAC1F;AACA;AACA,qCAAqC,yCAAyC;AAC9E,cAAc;AACd;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wFAAwF,SAAS;AACjG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sFAAsF,SAAS;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD,iBAAiB;AACtE;AACA;AACA;AACA;AACA;AACA;AACA,6EAA6E,SAAS;AACtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,UAAU;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0FAA0F,SAAS;AACnG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wDAAwD,qCAAqC;AAC7F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C,yBAAyB,oCAAoC,wBAAwB;AACnI;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,mBAAmB;AACnB;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,UAAU;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yCAAyC,QAAQ;AACjD,6CAA6C,SAAS;AACtD;AACA;AACA;AACA,qBAAqB;AACrB,sBAAsB,mBAAmB;AACzC;AACA;AACA,0CAA0C,QAAQ;AAClD;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA,4IAA4I,aAAa;AACzJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA,uDAAuD,8CAA8C;AACrG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,wDAAwD,gCAAgC;AACxF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA,iEAAiE,qCAAqC;AACtG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qEAAqE,yBAAyB;AAC9F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8DAA8D,kCAAkC;AAChG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD,iBAAiB;AACtE;AACA;AACA;AACA;AACA;AACA;AACA,kFAAkF,SAAS;AAC3F;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAiD,iBAAiB;AAClE;AACA;AACA;AACA;AACA;AACA,6EAA6E,SAAS;AACtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wEAAwE,SAAS;AACjF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,WAAW,SAAS;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,kCAAkC;AAClC,oEAAoE,qCAAqC;AACzG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,WAAW,SAAS;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,WAAW,mBAAmB;AAC9B;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,eAAe;AACf;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC,UAAU;AAClD;AACA;AACA,gBAAgB;AAChB;AACA;AACA,aAAa;AACb;AACA,SAAS;AACT;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,kCAAkC;AAClC,iBAAiB,UAAU,4DAA4D,4BAA4B;AACnH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB,kCAAkC;AAClC,oEAAoE,mBAAmB;AACvF;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA,qEAAqE,mBAAmB;AACxF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B,iBAAiB;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+CAA+C,iBAAiB;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,uBAAuB;AACnD;AACA;AACA,4DAA4D,6DAA6D;AACzH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,yDAAyD,uBAAuB;AAChF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,2DAA2D,oBAAoB;AAC/E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mDAAmD,QAAQ;AAC3D,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,4BAA4B,yBAAyB;AACrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mDAAmD,QAAQ;AAC3D,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,gCAAgC,yBAAyB;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,+BAA+B;AAC/B;AACA;AACA;AACA,yBAAyB,qFAAqF;AAC9G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,uDAAuD,aAAa;AACpE,sBAAsB,SAAS;AAC/B;AACA,gCAAgC,MAAM;AACtC,UAAU;AACV;AACA,6CAA6C;AAC7C;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,oCAAoC;AACrD;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA;AACA,iDAAiD,aAAa;AAC9D;AACA;AACA;AACA,QAAQ,yBAAyB;AACjC,QAAQ,mBAAmB;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;;AAEA;;AAEA,+DAA+D,aAAa;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,mDAAmD,aAAa;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0DAA0D;AAC1D;AACA,sCAAsC,kDAAkD;AACxF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2EAA2E,+BAA+B;AAC1G;AACA;AACA,iBAAiB,UAAU;AAC3B;AACA,iBAAiB,UAAU;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8EAA8E,SAAS;AACvF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,SAAS;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uDAAuD,yBAAyB;AAChF;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oFAAoF,SAAS;AAC7F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,UAAU;AAC3B;AACA;AACA;AACA,yBAAyB,0CAA0C;AACnE;AACA;AACA,+CAA+C;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,yCAAyC;AAClE;AACA;AACA,+CAA+C;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+EAA+E,SAAS;AACxF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kFAAkF,SAAS;AAC3F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gFAAgF,SAAS;AACzF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gDAAgD,WAAW;AAC3D;AACA;AACA;AACA,iBAAiB;AACjB;AACA,cAAc;AACd;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0CAA0C,WAAW;AACrD;AACA,iBAAiB;AACjB;AACA;AACA;AACA,yCAAyC,iCAAiC;AAC1E;AACA;AACA;AACA,cAAc;AACd;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iFAAiF,SAAS;AAC1F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,gDAAgD,iDAAiD;AACjG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,yBAAyB;AAC/E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,cAAc;AACpD;AACA;AACA;AACA;AACA;AACA,gEAAgE,2BAA2B;AAC3F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,mBAAmB;AACjD;AACA,4CAA4C,+BAA+B;AAC3E;AACA,aAAa;AACb,SAAS;AACT;AACA;AACA;AACA;AACA,kDAAkD,sCAAsC;AACxF;AACA;AACA;AACA;AACA;AACA;AACA,qCAAqC,yBAAyB,8DAA8D,gBAAgB;AAC5I;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb,cAAc,mBAAmB;AACjC;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA,+BAA+B,UAAU;AACzC;AACA;AACA,cAAc;AACd;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB,kBAAkB,mBAAmB;AACrC;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA,0BAA0B;AAC1B;AACA;AACA;AACA,mCAAmC,0BAA0B;AAC7D;AACA;AACA,kBAAkB;AAClB;AACA;AACA,aAAa;AACb,SAAS;AACT;AACA;AACA;AACA,iBAAiB,UAAU,kDAAkD,2BAA2B;AACxG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2DAA2D,kBAAkB;AAC7E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,+DAA+D,wBAAwB;AACvF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD;AACrD;AACA;AACA;AACA;AACA;AACA,oBAAoB,kDAAkD;AACtE;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,kBAAkB;AACtC;AACA;AACA,oBAAoB,uBAAuB;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,iBAAiB;AAC9C;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8DAA8D,2BAA2B;AACzF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA,qEAAqE,eAAe;AACpF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA,iDAAiD,8BAA8B;AAC/E;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA,wCAAwC,8BAA8B;AACtE;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,yDAAyD,wCAAwC;AACjG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,iBAAiB,aAAa;AAC9B,4BAA4B,YAAY;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,iBAAiB,aAAa;AAC9B,gCAAgC,YAAY;AAC5C;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,oCAAoC;AACrD;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA;AACA,iDAAiD,aAAa;AAC9D;AACA;AACA;AACA,QAAQ,qBAAqB;AAC7B,QAAQ,eAAe;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;;AAEA;AACA;AACA;AACA,MAAM,cAAc;AACpB;AACA;AACA;AACA,8CAA8C,aAAa;AAC3D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oEAAoE,yCAAyC;AAC7G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,SAAS;AAClC;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,aAAa;AACb,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2DAA2D,SAAS;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,WAAW,SAAS,iDAAiD,aAAa;AAClG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+DAA+D,SAAS;AACxE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oEAAoE,SAAS;AAC7E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0EAA0E,SAAS;AACnF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,WAAW,QAAQ,gCAAgC;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,sBAAsB;AAC5D;AACA;AACA;AACA;AACA,0BAA0B;AAC1B,gBAAgB,WAAW,QAAQ,gCAAgC;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,SAAS;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA,yDAAyD,YAAY,UAAU,SAAS;AACxF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,qBAAqB,SAAS;AAC9B;AACA;AACA;AACA;AACA,YAAY,iEAAiE;AAC7E;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,SAAS;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mEAAmE,SAAS;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,gBAAgB,WAAW,QAAQ,oBAAoB,mDAAmD,aAAa;AACvH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sEAAsE,SAAS;AAC/E;AACA;AACA;AACA,gBAAgB,WAAW,QAAQ,oBAAoB;AACvD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iEAAiE,SAAS;AAC1E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8DAA8D,SAAS;AACvE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iEAAiE,SAAS;AAC1E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yDAAyD,SAAS;AAClE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gEAAgE,SAAS;AACzE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,SAAS;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR,QAAQ;AACR,QAAQ;AACR,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gEAAgE,SAAS;AACzE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,WAAW,SAAS;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,SAAS;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gEAAgE,SAAS;AACzE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4DAA4D,SAAS;AACrE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8DAA8D,SAAS;AACvE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2DAA2D,SAAS;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA,gBAAgB;AAChB;AACA,gBAAgB;AAChB;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,gBAAgB;AACtE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+DAA+D,KAAK;AACpE;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,4EAA4E;AACpF;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0CAA0C,yBAAyB;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,4EAA4E;AACpF;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mEAAmE,cAAc;AACjF;AACA;AACA;AACA;AACA;AACA,QAAQ,4EAA4E;AACpF;AACA;AACA;AACA;AACA;AACA,sCAAsC;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mEAAmE,cAAc,UAAU,SAAS;AACpG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,MAAM;AACxE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR,8DAA8D,mDAAmD;AACjH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC,sDAAsD;AAC7F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,iBAAiB;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yCAAyC,kBAAkB;AAC3D,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,yDAAyD,WAAW;AACpE,mDAAmD,WAAW;AAC9D,yDAAyD,WAAW;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,qBAAqB;AACzC,2DAA2D,eAAe;AAC1E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0DAA0D,YAAY;AACtE;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B,mEAAmE;AAC7F;AACA;AACA;AACA;AACA,QAAQ;AACR,2DAA2D,YAAY;AACvE;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+DAA+D,WAAW;AAC1E,yDAAyD,WAAW;AACpE,+DAA+D,WAAW;AAC1E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,qBAAqB;AAC7C,+DAA+D,eAAe;AAC9E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,YAAY;AACzE;AACA;AACA;AACA,aAAa;AACb,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,8BAA8B;AAC3C,aAAa;AACb;AACA;AACA;AACA,6BAA6B,oBAAoB;AACjD,mCAAmC,IAAI;AACvC,uCAAuC,QAAQ;AAC/C;AACA,yCAAyC,MAAM;AAC/C;AACA,YAAY;AACZ,QAAQ;AACR;AACA;AACA;AACA,kEAAkE,SAAS,UAAU,SAAS;AAC9F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6EAA6E,SAAS;AACtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC,gBAAgB;AACnD;AACA;AACA;AACA,2EAA2E,SAAS;AACpF;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,iBAAiB;AAC/C;AACA;AACA;AACA;AACA,oDAAoD,KAAK;AACzD,uEAAuE,SAAS;AAChF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2DAA2D,OAAO;AAClE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,qBAAqB,SAAS;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,4FAA4F;AACxG;AACA;AACA;AACA,0BAA0B,2FAA2F;AACrH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,qBAAqB,SAAS;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sEAAsE,MAAM,UAAU,SAAS;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2CAA2C,eAAe;AAC1D;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,OAAO;AACvB,mEAAmE,MAAM,UAAU,SAAS;AAC5F;AACA;AACA;AACA;AACA;AACA,sEAAsE,MAAM,UAAU,SAAS;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,gBAAgB,aAAa;AAC7B;AACA;AACA;AACA,gEAAgE,+BAA+B;AAC/F;AACA;AACA;AACA,iBAAiB;AACjB;AACA,sBAAsB,SAAS;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,oEAAoE,SAAS;AAC7E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,iCAAiC,0BAA0B;AACxE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gFAAgF;AAChF;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,QAAQ;AACR;AACA;AACA,+CAA+C;AAC/C,gBAAgB,0BAA0B;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,iDAAiD;AACzE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC,4BAA4B,GAAG,GAAG;AACzE,uCAAuC,uBAAuB,GAAG,GAAG;AACpE,uCAAuC,4BAA4B,GAAG,GAAG;AACzE,uCAAuC,yBAAyB,GAAG,GAAG;AACtE,uCAAuC,4BAA4B,GAAG,GAAG;AACzE,uCAAuC,yBAAyB,GAAG,GAAG;AACtE;AACA;AACA,2BAA2B,4BAA4B,GAAG,GAAG;AAC7D,2BAA2B,uBAAuB,GAAG,GAAG;AACxD,6BAA6B,4BAA4B,GAAG,GAAG;AAC/D,6BAA6B,yBAAyB,GAAG,GAAG;AAC5D,6BAA6B,4BAA4B,GAAG,GAAG;AAC/D,6BAA6B,yBAAyB,GAAG,GAAG;AAC5D;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B;AAC3B;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,gBAAgB,UAAU,4EAA4E,aAAa;AACnH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA,0BAA0B,YAAY;AACtC,uDAAuD,YAAY;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB,YAAY;AACZ;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA,gBAAgB,UAAU;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA,8EAA8E,SAAS;AACvF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,WAAW,SAAS;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4DAA4D,kCAAkC;AAC9F;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,UAAU;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,UAAU;AAC1B;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA,+CAA+C,aAAa;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8DAA8D,MAAM;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA,+EAA+E,kCAAkC;AACjH;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA,YAAY;AACZ,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mDAAmD,0BAA0B,iDAAiD,OAAO;AACrI;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD,0BAA0B,iDAAiD,OAAO;AACvI;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB;AACvB,WAAW;AACX,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB;AACvB,WAAW;AACX,QAAQ;AACR;AACA;AACA;AACA;AACA,2EAA2E,MAAM;AACjF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C,aAAa;AAC3D;AACA;AACA;AACA;AACA;AACA,IAAI,uCAAuC;AAC3C,iBAAiB,uCAAuC;AACxD,mDAAmD,sCAAsC;AACzF;AACA;AACA,OAAO;AACP,OAAO;AACP,OAAO;AACP;AACA;AACA,OAAO;AACP,OAAO;AACP;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,OAAO;AACP,OAAO;AACP,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA,+EAA+E,iCAAiC;AAChH;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,SAAS,UAAU,SAAS;AACzF,YAAY;AACZ,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qFAAqF,YAAY;AACjG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,0BAA0B;AAC1C;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA,kDAAkD,aAAa;AAC/D;AACA;AACA,0CAA0C,MAAM,EAAE,sCAAsC,iBAAiB,OAAO;AAChH;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8EAA8E,WAAW;AACzF;AACA;AACA;AACA,8BAA8B;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA,aAAa;AACb;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uEAAuE,UAAU,UAAU,UAAU,gBAAgB,YAAY;AACjI;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B;;AAE3B;;AAEA;;AAEA;;AAEA,8CAA8C,aAAa;AAC3D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,uBAAuB;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yCAAyC,cAAc;AACvD;AACA,kDAAkD,iBAAiB;AACnE,aAAa;AACb,4DAA4D,4BAA4B;AACxF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,OAAO;AACzB;AACA;AACA;AACA,oBAAoB,qCAAqC;AACzD,oBAAoB,kBAAkB;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,kBAAkB,OAAO;AACzB;AACA;AACA;AACA,oBAAoB,6BAA6B;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wEAAwE,mBAAmB;AAC3F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uDAAuD,YAAY;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4DAA4D,mBAAmB;AAC/E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB;;AAEvB;;AAEA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iFAAiF,uBAAuB;AACxG;AACA;AACA;AACA;AACA;AACA,+EAA+E,uBAAuB;AACtG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,gBAAgB;AAC7C;AACA;AACA,+BAA+B,gBAAgB;AAC/C;AACA;AACA,0BAA0B,KAAK;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,kCAAkC;AAC/F;AACA,SAAS;AACT;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+DAA+D,kCAAkC;AACjG;AACA,SAAS;AACT;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA,yDAAyD,aAAa;AACtE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA,iGAAiG,oCAAoC;AACrI,wBAAwB,yCAAyC,oBAAoB;AACrF,8EAA8E,wCAAwC;AACtH;AACA;AACA,OAAO;AACP,OAAO;AACP,OAAO;AACP,OAAO;AACP,OAAO;AACP;AACA;AACA,OAAO;AACP,OAAO;AACP,OAAO;AACP;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,OAAO;AACP,OAAO;AACP,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iFAAiF,SAAS,UAAU,SAAS,gBAAgB,YAAY;AACzI;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4EAA4E,mCAAmC;AAC/G,YAAY;AACZ,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2DAA2D,SAAS,UAAU,SAAS;AACvF,YAAY;AACZ,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,oDAAoD;AACxE,qBAAqB;AACrB,SAAS;AACT;AACA;AACA;AACA;AACA,sCAAsC,QAAQ,oBAAoB,UAAU,oBAAoB,gBAAgB,2BAA2B;AAC3I;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,qBAAqB,QAAQ,oBAAoB,UAAU,oBAAoB,gBAAgB,2BAA2B;AAC1H;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,aAAa;AACjC;AACA;AACA;AACA;AACA,8EAA8E,QAAQ,KAAK,UAAU,MAAM;AAC3G,yFAAyF,OAAO;AAChG,kBAAkB,QAAQ,aAAa,UAAU,cAAc;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mDAAmD,aAAa;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,uDAAuD,aAAa;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,yFAAyF;AACzG;AACA;AACA,8EAA8E;AAC9E;AACA;AACA;AACA,kFAAkF,mBAAmB,UAAU,mBAAmB,gBAAgB,KAAK;AACvJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,uDAAuD,aAAa;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2FAA2F,2CAA2C;AACtI;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2FAA2F,2CAA2C;AACtI;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C;AAC7C;AACA;AACA,yDAAyD,aAAa;AACtE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yGAAyG;AACzG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,8DAA8D;AAC1F,kCAAkC;AAClC;AACA;AACA;AACA,mCAAmC;AACnC;AACA;AACA;AACA,6BAA6B;AAC7B;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC,6BAA6B;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kCAAkC;AAClC;AACA;AACA;AACA;AACA,gBAAgB,6EAA6E;AAC7F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD,6BAA6B;AAClF;AACA;AACA,gBAAgB,yCAAyC;AACzD;AACA;AACA;AACA;AACA;AACA,uCAAuC,6BAA6B;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0DAA0D,kCAAkC;AAC5F;AACA;AACA;AACA;AACA,4BAA4B,yCAAyC;AACrE;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA,qDAAqD,0DAA0D;AAC/G;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,MAAM,eAAe;AACrB,MAAM,6BAA6B;AACnC,MAAM,+BAA+B;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAiD,aAAa;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B;AAC1B,sBAAsB;AACtB,oBAAoB;AACpB,uBAAuB;AACvB;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,KAAK;AACL;AACA;AACA,2EAA2E,sCAAsC;AACjH,iCAAiC,kCAAkC;AACnE;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,OAAO;AACP,OAAO;AACP,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA,iBAAiB;AACjB;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gEAAgE,SAAS;AACzE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yEAAyE;AACzE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yEAAyE;AACzE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B;AAC5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,sFAAsF,8BAA8B;AACpH;AACA,0EAA0E,YAAY;AACtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sEAAsE,YAAY;AAClF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU,oBAAoB;AAC9B;AACA,6DAA6D,YAAY;AACzE;AACA;AACA;AACA;AACA,4BAA4B,qBAAqB;AACjD;AACA;AACA;AACA,qEAAqE,kCAAkC;AACvG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2CAA2C;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB;AACvB,gBAAgB,wBAAwB;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6FAA6F,kBAAkB,UAAU,kBAAkB,gBAAgB,uBAAuB;AAClL;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,4BAA4B,qBAAqB;AACjD;AACA;AACA;AACA,qEAAqE,sCAAsC;AAC3G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,WAAW,2BAA2B,iDAAiD,aAAa;AACpH;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;;AAEA,mDAAmD,aAAa;AAChE;AACA;AACA;AACA;AACA,MAAM,2BAA2B;AACjC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2CAA2C,WAAW;AACtD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gFAAgF,UAAU;AAC1F,gCAAgC,UAAU;AAC1C,0BAA0B,iBAAiB;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAiD,UAAU;AAC3D;AACA;AACA;AACA,mDAAmD,UAAU;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,WAAW,iEAAiE;AAC5F;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B;AACA;AACA,SAAS;AACT;AACA;AACA,gBAAgB,WAAW,kCAAkC;AAC7D,0BAA0B;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,SAAS;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,KAAK;AACnC,KAAK;AACL;AACA;;AAEA;;AAEA;AACA;AACA;AACA,MAAM,iBAAiB;AACvB;AACA;AACA;AACA,iDAAiD,aAAa;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,UAAU,sDAAsD,MAAM;AACtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB;AACvB;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC,mBAAmB;AACvD,gBAAgB,UAAU;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,UAAU,sDAAsD,MAAM;AACtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,UAAU,qDAAqD,MAAM;AACrF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD,gCAAgC;AACrF;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,UAAU,yDAAyD,MAAM;AACzF;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA,+BAA+B,oEAAoE;AACnG,4CAA4C,0EAA0E;AACtH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4FAA4F,SAAS;AACrG;AACA;AACA;;AAEA,iDAAiD,aAAa;AAC9D;AACA;AACA;AACA;AACA,oEAAoE,2BAA2B;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,iFAAiF,MAAM;AACvF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,iEAAiE,MAAM;AACvE;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,gBAAgB,oCAAoC;AACpD;AACA;AACA,EAAE;AACF;AACA;AACA,EAAE;AACF;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA,OAAO,iCAAiC;AACxC,OAAO,2BAA2B;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAE;;AAEF;;AAEA;;AAEA;;AAEA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,uDAAuD;AACpH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iEAAiE,gDAAgD;AACjH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6EAA6E,SAAS;AACtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gFAAgF,SAAS;AACzF;AACA;AACA;;AAEA,iDAAiD,aAAa;AAC9D;AACA;AACA;AACA;AACA;AACA,oEAAoE,cAAc;AAClF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,sCAAsC;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC,sCAAsC;AAC9E;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,OAAO,oBAAoB;AAC3B,OAAO,cAAc;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,oCAAoC;AACpD;AACA;AACA,EAAE;AACF;AACA;AACA,EAAE;AACF;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA,EAAE;;AAEF;;AAEA,oDAAoD,aAAa;AACjE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,QAAQ;AAC9B,QAAQ;AACR;AACA;AACA,QAAQ;AACR;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA,+DAA+D,QAAQ;AACvE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA,iEAAiE,QAAQ;AACzE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qEAAqE;AACrE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAiC,QAAQ,kBAAkB,WAAW;AACtE,QAAQ;AACR;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA,gBAAgB,WAAW,SAAS,8DAA8D,QAAQ;AAC1G;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,6CAA6C;AACtE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,oBAAoB,OAAO;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oDAAoD,KAAK;AACzD,0EAA0E,aAAa;AACvF;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC,+CAA+C;AACvF;AACA;AACA,gCAAgC;AAChC,yBAAyB;AACzB;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,mIAAmI,yBAAyB;AAC5J;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B;AAC5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+EAA+E;AAC/E;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,qIAAqI,yBAAyB;AAC9J;AACA,gBAAgB,WAAW;AAC3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,mCAAmC,8CAA8C;AACjF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC,8BAA8B;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,2BAA2B;AAC7F;AACA;AACA;AACA;AACA;AACA,4CAA4C,+CAA+C;AAC3F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,cAAc;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2DAA2D,uCAAuC;AAClG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4CAA4C,4BAA4B;AACxE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iEAAiE,4BAA4B;AAC7F;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA,mCAAmC,OAAO,IAAI,IAAI;AAClD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,iCAAiC,iDAAiD;AAClF;AACA;AACA,0CAA0C,kCAAkC;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4DAA4D,aAAa;AACzE;AACA;AACA;AACA;AACA;AACA;AACA,2FAA2F,+CAA+C;AAC1I;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,kDAAkD,uBAAuB;AACzE;AACA;AACA;AACA;AACA,kCAAkC,iDAAiD;AACnF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC,SAAS;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC,SAAS;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC;AACvC;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,gBAAgB,aAAa;AAC7B;AACA;AACA;AACA,gCAAgC;AAChC,SAAS;AACT;AACA;AACA,+EAA+E,iDAAiD;AAChI;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B;AAC/B;AACA;AACA;AACA,+BAA+B,KAAK;AACpC;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC;AACtC;AACA;AACA,yCAAyC;AACzC;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,gBAAgB,aAAa;AAC7B;AACA,gCAAgC,gDAAgD;AAChF;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uFAAuF,oCAAoC;AAC3H;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+CAA+C,wBAAwB;AACvE;AACA;AACA;AACA,4CAA4C,yBAAyB;AACrE;AACA;AACA,SAAS;AACT;AACA,iDAAiD,mBAAmB;AACpE;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA,mDAAmD,aAAa;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB;;AAExB;AACA;AACA;AACA;AACA;AACA;AACA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0EAA0E,2CAA2C;AACrH;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,cAAc;AAC9B;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,IAAI;AACJ;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uUAAuU,yCAAyC;AAChX;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B,4BAA4B;AAC3D,8BAA8B;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B;AAC5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA,wBAAwB;AACxB,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,kCAAkC;AAClC;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA,wBAAwB;AACxB,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,aAAa;AACb;AACA;AACA;AACA;AACA,sCAAsC,oBAAoB;AAC1D;AACA;AACA;AACA,sCAAsC,oBAAoB;AAC1D;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,oBAAoB,aAAa;AACjC;AACA;AACA;AACA;AACA;AACA,wBAAwB;AACxB,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD,qBAAqB;AAC1E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wDAAwD,gBAAgB;AACxE;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAiD,aAAa;AAC9D;AACA;AACA;AACA;AACA;AACA,oEAAoE,cAAc;AAClF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,cAAc;AACrC;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB,YAAY;AACZ;AACA;AACA;AACA,2DAA2D,aAAa;AACxE;AACA;AACA,uCAAuC;AACvC;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAiC;AACjC;AACA;AACA;AACA,yCAAyC;AACzC;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C;AAC7C;AACA,iEAAiE,eAAe;AAChF;AACA;AACA,aAAa;AACb,0EAA0E,6BAA6B;AACvG;AACA;AACA;AACA,iEAAiE,eAAe;AAChF;AACA;AACA;AACA;AACA,aAAa;AACb;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,gBAAgB,aAAa;AAC7B,2BAA2B,YAAY;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,gBAAgB,aAAa;AAC7B,+BAA+B,YAAY;AAC3C;AACA;AACA;AACA;AACA;AACA,mEAAmE,OAAO;AAC1E;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,OAAO,oBAAoB;AAC3B,OAAO,cAAc;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,oCAAoC;AACpD;AACA;AACA,EAAE;AACF;AACA;AACA,EAAE;AACF;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA,EAAE;;AAEF,iDAAiD,aAAa;AAC9D;AACA;AACA;AACA;AACA;AACA,oEAAoE,gBAAgB;AACpF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,cAAc;AACjC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B;AAC5B;AACA,qCAAqC,cAAc;AACnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B,iBAAiB;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,WAAW;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,2CAA2C,qBAAqB;AAChE;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,WAAW;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,2CAA2C,qBAAqB;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,2BAA2B,yBAAyB;AACpD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,+BAA+B,yBAAyB;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,wBAAwB,OAAO;AAC/B;AACA,iEAAiE,gDAAgD;AACjH;AACA;AACA,6EAA6E,MAAM;AACnF;AACA,2BAA2B,MAAM;AACjC;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6EAA6E,yBAAyB;AACtG;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,gBAAgB,oCAAoC;AACpD;AACA;AACA,EAAE;AACF;AACA;AACA,EAAE;AACF;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA,OAAO,sBAAsB;AAC7B,OAAO,gBAAgB;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAE;;AAEF;;AAEA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA,aAAa,yBAAyB;AACtC;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA,0DAA0D,YAAY;AACtE;AACA;AACA,cAAc;AACd;AACA,+DAA+D,YAAY;AAC3E;AACA;AACA,cAAc;AACd;AACA,6DAA6D,YAAY;AACzE;AACA;AACA,cAAc;AACd;AACA,yFAAyF,MAAM;AAC/F;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAE;;AAEF;;AAEA;;AAEA;;AAEA,0DAA0D,aAAa;AACvE;AACA;AACA;AACA;AACA;AACA,uBAAuB;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA,kEAAkE,aAAa;AAC/E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,QAAQ;AAC1E,kEAAkE,QAAQ;AAC1E,oEAAoE,QAAQ;AAC5E,sEAAsE,QAAQ;AAC9E;AACA;AACA;AACA;AACA;AACA,iBAAiB,UAAU;AAC3B;AACA;AACA,6EAA6E,mCAAmC,aAAa,wBAAwB;AACrJ;AACA;AACA;AACA;AACA,sDAAsD,qBAAqB,EAAE,qBAAqB;AAClG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA,iBAAiB,yBAAyB;AAC1C;AACA;AACA,sDAAsD,qBAAqB,EAAE,qBAAqB;AAClG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA,iBAAiB,YAAY;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA,oGAAoG,UAAU,oBAAoB,eAAe;AACjJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,gDAAgD,aAAa;AAC7D;AACA,6BAA6B,cAAc,EAAE,WAAW;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,WAAW,mBAAmB,aAAa,IAAI,MAAM;AAC3G;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC,WAAW,MAAM,WAAW;AACpE;AACA;AACA;AACA,aAAa,aAAa;AAC1B;AACA,oCAAoC,KAAK,GAAG,MAAM,aAAa,kBAAkB,KAAK,eAAe,MAAM,WAAW;AACtH,oCAAoC,KAAK,GAAG,MAAM,aAAa,eAAe,MAAM,WAAW;AAC/F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,UAAU,IAAI,MAAM;AAC1E;AACA;AACA;AACA;AACA;AACA,EAAE;;AAEF;;AAEA;;AAEA;AACA;AACA;AACA,+DAA+D,aAAa;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,aAAa;AAClC;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,iBAAiB,UAAU;AAC3B;AACA;AACA,sDAAsD,gCAAgC,EAAE,+BAA+B;AACvH;AACA;AACA;AACA,2EAA2E,mCAAmC,aAAa,wBAAwB;AACnJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,iBAAiB,cAAc;AAC/B;AACA;AACA,sDAAsD,2BAA2B,EAAE,0BAA0B;AAC7G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,yBAAyB;AAC1C;AACA;AACA,sDAAsD,2BAA2B,EAAE,0BAA0B;AAC7G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,iBAAiB,YAAY;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,kCAAkC,YAAY,2BAA2B;AAClG;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA,uGAAuG,OAAO,mBAAmB,UAAU,UAAU,4BAA4B,UAAU,4BAA4B,gBAAgB,kCAAkC;AACzQ;AACA;AACA;AACA;AACA,oGAAoG,UAAU,UAAU,4BAA4B,UAAU,4BAA4B,gBAAgB,kCAAkC;AAC5O;AACA;AACA;AACA,iBAAiB,YAAY;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oGAAoG,UAAU,oBAAoB,GAAG;AACrI;AACA;AACA;AACA;AACA,iBAAiB,YAAY;AAC7B;AACA,sDAAsD,2BAA2B,EAAE,0BAA0B;AAC7G;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;AACA,UAAU;AACV;AACA;AACA;AACA,iBAAiB,YAAY;AAC7B;AACA,sDAAsD,SAAS,EAAE,QAAQ;AACzE;AACA;AACA;AACA;AACA;AACA,iBAAiB,YAAY;AAC7B;AACA,sDAAsD,SAAS,EAAE,QAAQ;AACzE;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,kCAAkC,EAAE,iCAAiC;AAC3H;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,aAAa;AAC9B;AACA;AACA;AACA;AACA;AACA,qBAAqB,kBAAkB,mCAAmC,0BAA0B;AACpG;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,kGAAkG,OAAO,8BAA8B,iCAAiC,UAAU,iCAAiC,gBAAgB,uCAAuC;AAC1Q;AACA;AACA;AACA;AACA,iBAAiB,aAAa;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA,yDAAyD,WAAW;AACpE,kBAAkB;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wDAAwD,4BAA4B;AACpF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,aAAa;AAClC;AACA;AACA,cAAc;AACd,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C;AAC9C;AACA;AACA,sDAAsD,aAAa;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,2FAA2F,iGAAiG;AAC5L,wBAAwB,oCAAoC;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,2HAA2H;AACjJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,mBAAmB;AACzD;AACA,kEAAkE,mBAAmB;AACrF;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,SAAS;AAC3B;AACA;AACA,UAAU;AACV;AACA;AACA,qBAAqB,iBAAiB;AACtC,uCAAuC,SAAS;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,qBAAqB,EAAE,qBAAqB;AAClG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B,SAAS;AACnC;AACA;AACA,UAAU;AACV;AACA;AACA,iHAAiH,eAAe;AAChI;AACA;AACA;AACA,6EAA6E,mCAAmC,aAAa,wBAAwB;AACrJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,iBAAiB,iBAAiB;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qGAAqG,mFAAmF;AACxL;AACA;AACA;AACA;AACA;AACA,8BAA8B,wBAAwB;AACtD;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,gBAAgB;AACtE;AACA;AACA;AACA;AACA;AACA,uDAAuD,aAAa,EAAE,aAAa;AACnF;AACA;AACA;AACA,iFAAiF,aAAa,EAAE,YAAY;AAC5G;AACA;AACA;AACA,kEAAkE,gBAAgB;AAClF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kDAAkD,gBAAgB;AAClE;AACA;AACA;AACA;AACA,6BAA6B,oEAAoE;AACjG;AACA;AACA;AACA;AACA;AACA,qCAAqC,gBAAgB;AACrD;AACA;AACA,UAAU;AACV;AACA;AACA,sDAAsD,qBAAqB,EAAE,qBAAqB;AAClG;AACA;AACA,wFAAwF,eAAe;AACvG;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,yBAAyB;AAClD;AACA;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B,6FAA6F;AACxH;AACA;AACA;AACA;AACA;AACA,oCAAoC,QAAQ;AAC5C;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+EAA+E,aAAa,EAAE,YAAY;AAC1G;AACA;AACA,iFAAiF,aAAa,EAAE,YAAY;AAC5G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,gFAAgF;AAC7G;AACA;AACA,oBAAoB,iBAAiB;AACrC;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,sBAAsB;AACtB,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,gBAAgB;AAC9C;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC,gBAAgB;AACnD;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wDAAwD,4CAA4C;AACpG;AACA,0DAA0D,oCAAoC;AAC9F,wEAAwE,+CAA+C;AACvH;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,sEAAsE;AACnG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,6CAA6C,YAAY;AACzD;AACA;AACA;AACA;AACA,oDAAoD,0CAA0C;AAC9F;AACA;AACA;AACA;AACA;AACA,6CAA6C,0CAA0C;AACvF;AACA;AACA;AACA;AACA,6BAA6B,iCAAiC;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA,mFAAmF,oBAAoB,GAAG,oBAAoB,GAAG,0BAA0B;AAC3J;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,wCAAwC;AACjE,wBAAwB,eAAe,IAAI,kBAAkB,IAAI,eAAe;AAChF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,wCAAwC;AACjE,wBAAwB,eAAe;AACvC,YAAY;AACZ;AACA,yBAAyB,wCAAwC;AACjE,wBAAwB,eAAe,IAAI,kBAAkB,IAAI,eAAe;AAChF,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,wCAAwC;AACjE,wBAAwB,eAAe,IAAI,kBAAkB,IAAI,eAAe;AAChF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC,aAAa;AAC7C,4DAA4D,KAAK,GAAG,MAAM;AAC1E;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,cAAc;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,WAAW,mBAAmB,cAAc,YAAY,oBAAoB,GAAG,oBAAoB,GAAG,0BAA0B;AAC7L;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC,UAAU;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2EAA2E,iGAAiG;AAC5K;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,cAAc;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wDAAwD,4CAA4C;AACpG;AACA,0DAA0D,oCAAoC;AAC9F,wEAAwE,+CAA+C;AACvH;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB,uCAAuC;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,kDAAkD;AACvE;AACA;AACA;AACA;AACA,iCAAiC,yBAAyB;AAC1D;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wJAAwJ,eAAe;AACvK;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC,wBAAwB;AACxD,+BAA+B;AAC/B;AACA;AACA;AACA,qBAAqB,iBAAiB;AACtC;AACA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,YAAY;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA,oDAAoD,mDAAmD;AACvG;AACA;AACA;AACA,+CAA+C,mDAAmD;AAClG;AACA;AACA,qBAAqB,iBAAiB;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iEAAiE,WAAW,aAAa,oBAAoB,GAAG,oBAAoB,GAAG,0BAA0B;AACjK;AACA;AACA;AACA;AACA,4BAA4B,WAAW;AACvC;AACA;AACA;AACA;AACA;AACA,qCAAqC,uBAAuB;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA,sBAAsB;AACtB;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,KAAK;AAC1B;AACA;AACA;AACA,0BAA0B;AAC1B;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA,0BAA0B;AAC1B;AACA;AACA;AACA,sBAAsB;AACtB;AACA,kBAAkB;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kFAAkF,MAAM;AACxF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,oBAAoB,IAAI,oBAAoB;AAC9G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;AACA,cAAc;AACd;AACA,UAAU;AACV;AACA;AACA,4CAA4C,OAAO,uBAAuB,oBAAoB,IAAI,oBAAoB;AACtH;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,qBAAqB,YAAY;AACjC;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mEAAmE,aAAa;AAChF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,iEAAiE,QAAQ;AACzE;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,iEAAiE,QAAQ;AACzE;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,wDAAwD,QAAQ,GAAG,YAAY,GAAG,4BAA4B;AAC9G;AACA;AACA,wDAAwD,QAAQ;AAChE;AACA;AACA,kEAAkE,QAAQ,KAAK,wBAAwB;AACvG,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA,wEAAwE,QAAQ,KAAK,WAAW;AAChG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,eAAe,oCAAoC;AACnD;AACA;AACA,CAAC;AACD;AACA;AACA,CAAC;AACD;AACA,0CAA0C,4BAA4B;AACtE,CAAC;AACD;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8DAA8D,aAAa;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mDAAmD,SAAS;AAC5D;AACA;AACA,2DAA2D,aAAa;AACxE;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAiD,QAAQ,GAAG,YAAY,GAAG,qBAAqB;AAChG;AACA;AACA,iDAAiD,QAAQ,GAAG,qBAAqB;AACjF;AACA;AACA,2BAA2B;AAC3B;AACA,4DAA4D,wBAAwB;AACpF;AACA;AACA;AACA;AACA;AACA;AACA,sEAAsE,WAAW;AACjF;AACA;AACA;AACA;AACA;AACA;AACA,kEAAkE,WAAW;AAC7E;AACA;AACA;AACA,0DAA0D,QAAQ,GAAG,qBAAqB;AAC1F;AACA,2BAA2B;AAC3B;AACA,2DAA2D,WAAW;AACtE;AACA;AACA;AACA,iDAAiD,QAAQ,GAAG,qBAAqB;AACjF;AACA,2BAA2B;AAC3B;AACA,2DAA2D,WAAW;AACtE;AACA;AACA;AACA,kDAAkD,QAAQ,GAAG,qBAAqB;AAClF;AACA,2BAA2B;AAC3B;AACA,4DAA4D,WAAW;AACvE;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,8CAA8C;AAC9C;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC,SAAS,sBAAsB,aAAa,8BAA8B,YAAY,wDAAwD,aAAa;AAC9L;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAE,gEAAgE;AAClE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAE,oDAAoD;AACtD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qDAAqD,WAAW;AAChE;AACA;AACA;AACA;AACA;AACA,iBAAiB,OAAO;AACxB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,WAAW;AAC5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C;AAC7C;AACA;AACA,6CAA6C,WAAW;AACxD;AACA,UAAU;AACV,MAAM;AACN;AACA,8BAA8B,8CAA8C,IAAI;AAChF,kCAAkC,kCAAkC,IAAI;AACxE;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,QAAQ;AACzB;AACA;AACA;AACA;AACA,qBAAqB,WAAW;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA,EAAE;;AAEF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C;AAC9C;AACA;AACA,mDAAmD,aAAa;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,iGAAiG,cAAc;AAC/G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB;AACtB,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,yBAAyB,aAAa;AACtC;AACA,cAAc;AACd,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kBAAkB;AAClB;AACA;AACA;AACA;AACA;AACA,cAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,mCAAmC;AACzE,SAAS,kFAAkF;AAC3F;AACA,kCAAkC,qBAAqB,IAAI,gBAAgB;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,0BAA0B;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,qBAAqB,oCAAoC;AACzD,qBAAqB,WAAW;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uIAAuI,sEAAsE;AAC7M;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,iBAAiB,mCAAmC;AACpD,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,yDAAyD,uBAAuB;AAChF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,6DAA6D,wBAAwB,eAAe;AACpG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,kCAAkC,kBAAkB;AACpD;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC,mCAAmC;AACzE,SAAS,oFAAoF;AAC7F;AACA,kCAAkC,qBAAqB,IAAI,gBAAgB;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,0BAA0B;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+GAA+G,eAAe,qBAAqB;AACnJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,yBAAyB,2BAA2B;AACpD,mDAAmD,SAAS;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,yDAAyD,mCAAmC,cAAc;AAC1G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,wCAAwC,qBAAqB,eAAe;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,mHAAmH,eAAe,qBAAqB;AACvJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,mHAAmH,eAAe,qBAAqB;AACvJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,oCAAoC;AACzD,qBAAqB,qCAAqC;AAC1D;AACA;AACA,iDAAiD,oBAAoB,IAAI;AACzE;AACA;AACA;AACA;AACA;AACA,wCAAwC;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4EAA4E,oBAAoB;AAChG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0GAA0G,WAAW;AACrH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB;AACtB,UAAU;AACV;AACA;AACA;AACA;AACA,gCAAgC,iDAAiD;AACjF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC,iDAAiD;AACjF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4FAA4F,oBAAoB;AAChH;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C;AAC9C;AACA;AACA,sDAAsD,aAAa;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+CAA+C;AAC/C,sGAAsG;AACtG;AACA;AACA;AACA;AACA,iBAAiB,8CAA8C;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR,QAAQ;AACR,QAAQ;AACR,QAAQ;AACR;AACA;AACA;AACA,QAAQ;AACR,QAAQ;AACR,QAAQ;AACR,QAAQ;AACR,QAAQ;AACR;AACA;AACA,QAAQ;AACR,QAAQ;AACR,QAAQ;AACR,QAAQ;AACR,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uCAAuC,yBAAyB,QAAQ;AACxE;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,gDAAgD,SAAS;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,WAAW;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,WAAW;AAC/B;AACA;AACA;AACA;AACA,oBAAoB,WAAW;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,WAAW;AAC/B;AACA;AACA;AACA;AACA,oBAAoB,WAAW;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA,iDAAiD,YAAY,GAAG,0BAA0B;AAC1F;AACA;AACA;AACA;AACA;AACA;AACA,6DAA6D,wBAAwB;AACrF;AACA;AACA;AACA,iEAAiE,WAAW;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,sDAAsD,wBAAwB;AAC9E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,4DAA4D,QAAQ;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,iEAAiE,gBAAgB;AACjF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,4DAA4D,gBAAgB;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B,+BAA+B;AACzD;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,UAAU;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,6CAA6C,WAAW;AACxD;AACA;AACA;AACA,gEAAgE,uBAAuB;AACvF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0CAA0C,0BAA0B,gBAAgB;AACpF;AACA;AACA;AACA;AACA,0CAA0C,uBAAuB,kBAAkB;AACnF,0CAA0C,0BAA0B,gBAAgB;AACpF;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,uDAAuD,aAAa;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sDAAsD,+CAA+C;AACrG,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA,0CAA0C,WAAW;AACrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,cAAc;AACnC;AACA,cAAc;AACd;AACA,8EAA8E,sBAAsB;AACpG;AACA;AACA;AACA;AACA;AACA;AACA,2FAA2F,sBAAsB,KAAK,MAAM;AAC5H;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,yBAAyB;AAC7C,4DAA4D,YAAY;AACxE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,qBAAqB,OAAO;AAC5B,wBAAwB,iEAAiE;AACzF,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mEAAmE,QAAQ;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA,sDAAsD,aAAa;AACnE;AACA;AACA,iDAAiD,0BAA0B;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA,kPAAkP,yBAAyB;AAC3Q;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,8CAA8C;AAC9C;AACA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oGAAoG,yBAAyB;AAC7H;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA,kFAAkF,KAAK;AACvF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,mFAAmF,KAAK;AACxF;AACA,cAAc;AACd,UAAU;AACV;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,qBAAqB;AAC7B,QAAQ,qBAAqB,KAAK,qBAAqB;AACvD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,oCAAoC;AACrD;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA;AACA,iDAAiD,aAAa;AAC9D;AACA;AACA;AACA,GAAG;AACH;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA,6CAA6C,aAAa;AAC1D;AACA;AACA,gDAAgD,cAAc,EAAE,QAAQ;AACxE;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wDAAwD,uCAAuC;AAC/F;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA,iGAAiG,aAAa;AAC9G;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC,kDAAkD;AACrF;AACA;AACA;AACA;AACA;AACA;AACA,iCAAiC,cAAc;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gEAAgE,oDAAoD;AACpH;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA,kEAAkE,oDAAoD;AACtH;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,mDAAmD,UAAU;AAC7D;AACA;AACA;AACA;;AAEA,+CAA+C,aAAa;AAC5D;AACA;AACA;AACA;AACA;AACA,oEAAoE,sBAAsB;AAC1F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB,SAAS;AACT,8CAA8C,UAAU;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,OAAO,4BAA4B;AACnC,OAAO,sBAAsB;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,oCAAoC;AACpD;AACA;AACA,EAAE;AACF;AACA;AACA,EAAE;AACF;AACA;AACA;AACA,gDAAgD,aAAa;AAC7D;AACA;AACA,EAAE;;AAEF,6CAA6C,aAAa;AAC1D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;;AAEA;;AAEA;;AAEA,4CAA4C,aAAa;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mEAAmE,wBAAwB;AAC3F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA,kDAAkD,aAAa;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,uDAAuD,aAAa;AACpE;AACA;AACA;AACA;AACA;AACA,YAAY,QAAQ;AACpB;AACA,gBAAgB,aAAa;AAC7B;AACA;AACA;AACA,gBAAgB,OAAO;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,UAAU;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6CAA6C;AAC7C;AACA;AACA,iDAAiD,aAAa;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4BAA4B,YAAY;AACxC,6BAA6B,wCAAwC;AACrE;AACA;AACA;AACA,SAAS;AACT,gBAAgB,aAAa;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC,sCAAsC,KAAK,GAAG;AACtF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,gBAAgB;AAChC,iCAAiC;AACjC;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,qCAAqC,mBAAmB;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA,yCAAyC,qBAAqB;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,sBAAsB;AAC1C;AACA,6BAA6B,wHAAwH;AACrJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAiC,kCAAkC;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,uDAAuD,aAAa;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kCAAkC,cAAc;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,gDAAgD,aAAa;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,KAAK;;AAEL,eAAe;AACf,kBAAe;AACf,WAAW;;;;;;;;;;;;AC7niBX;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEa;;AAEb;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,EAAE;AACF;AACA;AACA;AACA;AACA,EAAE;AACF;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,mBAAmB;;AAEnB;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,kBAAkB,sBAAsB;AACxC;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA,eAAe;AACf;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA,IAAI;AACJ;AACA;AACA,oBAAoB,SAAS;AAC7B;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA,MAAM;AACN;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;;AAEA,kCAAkC,QAAQ;AAC1C;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,oBAAoB,iBAAiB;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA,QAAQ;AACR;AACA,uCAAuC,QAAQ;AAC/C;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,MAAM;AACN;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,kBAAkB,OAAO;AACzB;AACA;AACA;;AAEA;AACA,SAAS,yBAAyB;AAClC;AACA;AACA;;AAEA;AACA;AACA,kBAAkB,gBAAgB;AAClC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA,8DAA8D,YAAY;AAC1E;AACA,8DAA8D,YAAY;AAC1E;AACA,GAAG;AACH;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA,qCAAqC,YAAY;AACjD;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,IAAI;AACJ;AACA;AACA;;;;;;;;;;;AChfA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,WAAW,mBAAO,CAAC,mDAAS;;AAE5B;AACA;;AAEA;;;;;;;;;;;ACNA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,cAAc,mBAAO,CAAC,yDAAY;AAClC,cAAc,mBAAO,CAAC,yDAAY;AAClC,cAAc,mBAAO,CAAC,yDAAY;;AAElC;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC/BA,qBAAqB,mBAAO,CAAC,uEAAmB;AAChD,sBAAsB,mBAAO,CAAC,yEAAoB;AAClD,mBAAmB,mBAAO,CAAC,mEAAiB;AAC5C,mBAAmB,mBAAO,CAAC,mEAAiB;AAC5C,mBAAmB,mBAAO,CAAC,mEAAiB;;AAE5C;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC/BA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,WAAW,mBAAO,CAAC,mDAAS;;AAE5B;AACA;;AAEA;;;;;;;;;;;ACNA,oBAAoB,mBAAO,CAAC,qEAAkB;AAC9C,qBAAqB,mBAAO,CAAC,uEAAmB;AAChD,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,kBAAkB,mBAAO,CAAC,iEAAgB;;AAE1C;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC/BA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,WAAW,mBAAO,CAAC,mDAAS;;AAE5B;AACA;;AAEA;;;;;;;;;;;ACNA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,WAAW,mBAAO,CAAC,mDAAS;;AAE5B;AACA;;AAEA;;;;;;;;;;;ACNA,eAAe,mBAAO,CAAC,2DAAa;AACpC,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,kBAAkB,mBAAO,CAAC,iEAAgB;;AAE1C;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;;;;;;;;;;AC1BA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,eAAe,mBAAO,CAAC,2DAAa;AACpC,eAAe,mBAAO,CAAC,2DAAa;AACpC,eAAe,mBAAO,CAAC,2DAAa;;AAEpC;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC1BA,WAAW,mBAAO,CAAC,mDAAS;;AAE5B;AACA;;AAEA;;;;;;;;;;;ACLA,WAAW,mBAAO,CAAC,mDAAS;;AAE5B;AACA;;AAEA;;;;;;;;;;;ACLA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,WAAW,mBAAO,CAAC,mDAAS;;AAE5B;AACA;;AAEA;;;;;;;;;;;ACNA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,UAAU;AACrB,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACrBA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,UAAU;AACrB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACxBA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,kBAAkB,mBAAO,CAAC,+DAAe;AACzC,cAAc,mBAAO,CAAC,uDAAW;AACjC,eAAe,mBAAO,CAAC,yDAAY;AACnC,cAAc,mBAAO,CAAC,yDAAY;AAClC,mBAAmB,mBAAO,CAAC,iEAAgB;;AAE3C;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,WAAW,SAAS;AACpB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AChDA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACnBA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,UAAU;AACrB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACtBA,sBAAsB,mBAAO,CAAC,yEAAoB;AAClD,SAAS,mBAAO,CAAC,6CAAM;;AAEvB;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,GAAG;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC3BA,SAAS,mBAAO,CAAC,6CAAM;;AAEvB;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,GAAG;AACd,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACpBA,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,WAAW,mBAAO,CAAC,iDAAQ;;AAE3B;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AChBA,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,aAAa,mBAAO,CAAC,qDAAU;;AAE/B;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AChBA,qBAAqB,mBAAO,CAAC,uEAAmB;;AAEhD;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,GAAG;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,IAAI;AACJ;AACA;AACA;;AAEA;;;;;;;;;;;ACxBA,YAAY,mBAAO,CAAC,qDAAU;AAC9B,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,mBAAmB,mBAAO,CAAC,mEAAiB;AAC5C,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,oBAAoB,mBAAO,CAAC,qEAAkB;AAC9C,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,mBAAmB,mBAAO,CAAC,mEAAiB;AAC5C,aAAa,mBAAO,CAAC,uDAAW;AAChC,qBAAqB,mBAAO,CAAC,uEAAmB;AAChD,qBAAqB,mBAAO,CAAC,uEAAmB;AAChD,sBAAsB,mBAAO,CAAC,yEAAoB;AAClD,cAAc,mBAAO,CAAC,uDAAW;AACjC,eAAe,mBAAO,CAAC,yDAAY;AACnC,YAAY,mBAAO,CAAC,mDAAS;AAC7B,eAAe,mBAAO,CAAC,yDAAY;AACnC,YAAY,mBAAO,CAAC,mDAAS;AAC7B,WAAW,mBAAO,CAAC,iDAAQ;AAC3B,aAAa,mBAAO,CAAC,qDAAU;;AAE/B;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,WAAW,SAAS;AACpB;AACA;AACA;AACA,WAAW,UAAU;AACrB,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,aAAa,GAAG;AAChB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;;AAEA;AACA;AACA;AACA;AACA,uCAAuC;AACvC;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;AACL,IAAI;AACJ;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;;AAEA;;;;;;;;;;;ACrKA,eAAe,mBAAO,CAAC,yDAAY;;AAEnC;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;;;;;;;;;;;AC7BA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,cAAc,mBAAO,CAAC,uDAAW;;AAEjC;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,UAAU;AACrB,WAAW,UAAU;AACrB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACnBA,aAAa,mBAAO,CAAC,uDAAW;AAChC,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,qBAAqB,mBAAO,CAAC,uEAAmB;;AAEhD;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC3BA,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,mBAAmB,mBAAO,CAAC,iEAAgB;;AAE3C;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACjBA,sBAAsB,mBAAO,CAAC,yEAAoB;AAClD,mBAAmB,mBAAO,CAAC,iEAAgB;;AAE3C;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,WAAW,GAAG;AACd,WAAW,SAAS;AACpB;AACA;AACA,WAAW,UAAU;AACrB,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC3BA,YAAY,mBAAO,CAAC,qDAAU;AAC9B,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,mBAAmB,mBAAO,CAAC,mEAAiB;AAC5C,aAAa,mBAAO,CAAC,uDAAW;AAChC,cAAc,mBAAO,CAAC,uDAAW;AACjC,eAAe,mBAAO,CAAC,yDAAY;AACnC,mBAAmB,mBAAO,CAAC,iEAAgB;;AAE3C;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,UAAU;AACrB,WAAW,UAAU;AACrB,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AClFA,aAAa,mBAAO,CAAC,uDAAW;AAChC,mBAAmB,mBAAO,CAAC,iEAAgB;;AAE3C;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACjBA,iBAAiB,mBAAO,CAAC,6DAAc;AACvC,eAAe,mBAAO,CAAC,2DAAa;AACpC,eAAe,mBAAO,CAAC,yDAAY;AACnC,eAAe,mBAAO,CAAC,2DAAa;;AAEpC;AACA;AACA;AACA;AACA,oCAAoC;;AAEpC;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC9CA,aAAa,mBAAO,CAAC,uDAAW;AAChC,mBAAmB,mBAAO,CAAC,iEAAgB;;AAE3C;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACjBA,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,eAAe,mBAAO,CAAC,yDAAY;AACnC,mBAAmB,mBAAO,CAAC,iEAAgB;;AAE3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC3DA,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC7BA,eAAe,mBAAO,CAAC,yDAAY;AACnC,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,mBAAmB,mBAAO,CAAC,mEAAiB;;AAE5C;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AChCA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,UAAU;AACrB,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACnBA;AACA;AACA;AACA;AACA,WAAW,UAAU;AACrB,aAAa,UAAU;AACvB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACbA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACZA,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA;AACA;AACA;AACA,WAAW,aAAa;AACxB,aAAa,aAAa;AAC1B;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;ACfA,WAAW,mBAAO,CAAC,mDAAS;;AAE5B;AACA,kBAAkB,KAA0B;;AAE5C;AACA,gCAAgC,QAAa;;AAE7C;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,SAAS;AACpB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;;;;;;;;;;AClCA,uBAAuB,mBAAO,CAAC,2EAAqB;;AAEpD;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,SAAS;AACpB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACfA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AChBA,aAAa,mBAAO,CAAC,uDAAW;;AAEhC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACjBA,uBAAuB,mBAAO,CAAC,2EAAqB;;AAEpD;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,SAAS;AACpB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACfA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACnBA,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,sBAAsB,mBAAO,CAAC,yEAAoB;;AAElD;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,OAAO;AAClB,WAAW,QAAQ,UAAU;AAC7B,WAAW,UAAU;AACrB,aAAa,QAAQ;AACrB;AACA;AACA;AACA,wBAAwB;;AAExB;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACvCA,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ,UAAU;AAC7B,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACfA,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,mBAAmB,mBAAO,CAAC,mEAAiB;;AAE5C;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ,UAAU;AAC7B,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACfA,WAAW,mBAAO,CAAC,mDAAS;;AAE5B;AACA;;AAEA;;;;;;;;;;;ACLA,gBAAgB,mBAAO,CAAC,6DAAc;;AAEtC;AACA;AACA;AACA,WAAW,QAAQ;AACnB;AACA,IAAI;AACJ,CAAC;;AAED;;;;;;;;;;;ACVA,eAAe,mBAAO,CAAC,2DAAa;AACpC,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,eAAe,mBAAO,CAAC,2DAAa;;AAEpC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,QAAQ;AACnB,WAAW,UAAU;AACrB,WAAW,UAAU;AACrB,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACnFA,aAAa,mBAAO,CAAC,uDAAW;AAChC,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,SAAS,mBAAO,CAAC,6CAAM;AACvB,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,UAAU;AACrB,WAAW,UAAU;AACrB,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC/GA,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,UAAU;AACrB,WAAW,UAAU;AACrB,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACzFA;AACA,wBAAwB,qBAAM,gBAAgB,qBAAM,IAAI,qBAAM,sBAAsB,qBAAM;;AAE1F;;;;;;;;;;;ACHA,qBAAqB,mBAAO,CAAC,uEAAmB;AAChD,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,WAAW,mBAAO,CAAC,iDAAQ;;AAE3B;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACfA,qBAAqB,mBAAO,CAAC,uEAAmB;AAChD,mBAAmB,mBAAO,CAAC,mEAAiB;AAC5C,aAAa,mBAAO,CAAC,qDAAU;;AAE/B;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AChBA,gBAAgB,mBAAO,CAAC,6DAAc;;AAEtC;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,aAAa,GAAG;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACjBA,mBAAmB,mBAAO,CAAC,mEAAiB;AAC5C,eAAe,mBAAO,CAAC,2DAAa;;AAEpC;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,aAAa,GAAG;AAChB;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AChBA,cAAc,mBAAO,CAAC,yDAAY;;AAElC;AACA;;AAEA;;;;;;;;;;;ACLA,aAAa,mBAAO,CAAC,uDAAW;;AAEhC;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,IAAI;;AAEJ;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC7CA,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,gBAAgB,mBAAO,CAAC,2DAAa;;AAErC;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;;;;;;;;;;;AC7BA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,mBAAmB,mBAAO,CAAC,mEAAiB;AAC5C,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,gBAAgB,mBAAO,CAAC,2DAAa;;AAErC;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACxBA,eAAe,mBAAO,CAAC,2DAAa;AACpC,UAAU,mBAAO,CAAC,iDAAQ;AAC1B,cAAc,mBAAO,CAAC,yDAAY;AAClC,UAAU,mBAAO,CAAC,iDAAQ;AAC1B,cAAc,mBAAO,CAAC,yDAAY;AAClC,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,eAAe,mBAAO,CAAC,2DAAa;;AAEpC;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,QAAQ;AACrB;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACzDA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,aAAa,GAAG;AAChB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACZA,mBAAmB,mBAAO,CAAC,mEAAiB;;AAE5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AChBA,mBAAmB,mBAAO,CAAC,mEAAiB;;AAE5C;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,GAAG;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC7BA,mBAAmB,mBAAO,CAAC,mEAAiB;;AAE5C;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACtBA,mBAAmB,mBAAO,CAAC,mEAAiB;;AAE5C;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,GAAG;AACd,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACtBA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACzBA,uBAAuB,mBAAO,CAAC,2EAAqB;AACpD,oBAAoB,mBAAO,CAAC,qEAAkB;AAC9C,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,kBAAkB,mBAAO,CAAC,iEAAgB;AAC1C,sBAAsB,mBAAO,CAAC,yEAAoB;;AAElD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,QAAQ;AACnB,WAAW,SAAS;AACpB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC5EA,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,mBAAmB,mBAAO,CAAC,mEAAiB;AAC5C,kBAAkB,mBAAO,CAAC,iEAAgB;;AAE1C;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACjBA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACxBA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACdA,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA,WAAW,UAAU;AACrB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACnBA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;;;;;;;;;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACZA,mBAAmB,mBAAO,CAAC,mEAAiB;;AAE5C;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AClCA,mBAAmB,mBAAO,CAAC,mEAAiB;;AAE5C;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,GAAG;AAChB;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;;;;;;;;;;AClBA,mBAAmB,mBAAO,CAAC,mEAAiB;;AAE5C;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACfA,mBAAmB,mBAAO,CAAC,mEAAiB;;AAE5C;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,GAAG;AACd,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACzBA,WAAW,mBAAO,CAAC,mDAAS;AAC5B,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,UAAU,mBAAO,CAAC,iDAAQ;;AAE1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACpBA,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACjBA,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,GAAG;AAChB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACfA,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACfA,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,GAAG;AACd,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACrBA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;AACA;AACA,GAAG;AACH;AACA;;AAEA;;;;;;;;;;;ACjBA,gBAAgB,mBAAO,CAAC,6DAAc;;AAEtC;AACA;;AAEA;;;;;;;;;;;ACLA,cAAc,mBAAO,CAAC,yDAAY;;AAElC;AACA;;AAEA;;;;;;;;;;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;ACnBA,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA,kBAAkB,KAA0B;;AAE5C;AACA,gCAAgC,QAAa;;AAE7C;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,IAAI;AACJ,CAAC;;AAED;;;;;;;;;;;AC7BA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACrBA;AACA;AACA;AACA;AACA,WAAW,UAAU;AACrB,WAAW,UAAU;AACrB,aAAa,UAAU;AACvB;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACdA,iBAAiB,mBAAO,CAAC,+DAAe;;AAExC;AACA;;AAEA;AACA;;AAEA;;;;;;;;;;;ACRA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AClBA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACbA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;;AAEA;AACA;AACA,GAAG;AACH;AACA;;AAEA;;;;;;;;;;;ACjBA,gBAAgB,mBAAO,CAAC,6DAAc;;AAEtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;;;;;;;;;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,GAAG;AAChB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,SAAS;AACtB;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACbA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,UAAU,mBAAO,CAAC,iDAAQ;AAC1B,eAAe,mBAAO,CAAC,2DAAa;;AAEpC;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,WAAW,GAAG;AACd,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACjCA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,UAAU;AACrB,aAAa,QAAQ;AACrB;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA,MAAM;AACN;AACA;AACA;;AAEA;;;;;;;;;;;ACzBA,gBAAgB,mBAAO,CAAC,6DAAc;;AAEtC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,GAAG;AAChB;AACA;AACA;AACA,oBAAoB,QAAQ,IAAI,QAAQ;AACxC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA,kBAAkB;AAClB,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACpCA,sBAAsB,mBAAO,CAAC,yEAAoB;AAClD,mBAAmB,mBAAO,CAAC,iEAAgB;;AAE3C;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA,8BAA8B,mBAAmB;AACjD;AACA;AACA;AACA;AACA;AACA,+CAA+C,mBAAmB;AAClE;AACA;AACA;;AAEA;;;;;;;;;;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACzBA,iBAAiB,mBAAO,CAAC,6DAAc;AACvC,eAAe,mBAAO,CAAC,yDAAY;;AAEnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;AChCA,WAAW,mBAAO,CAAC,mDAAS;AAC5B,gBAAgB,mBAAO,CAAC,2DAAa;;AAErC;AACA,kBAAkB,KAA0B;;AAE5C;AACA,gCAAgC,QAAa;;AAE7C;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACrCA,kBAAkB,mBAAO,CAAC,iEAAgB;;AAE1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA,kBAAkB;AAClB,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AClCA,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,eAAe,mBAAO,CAAC,yDAAY;;AAEnC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACpCA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AClCA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,eAAe,mBAAO,CAAC,2DAAa;;AAEpC;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA,oBAAoB;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC5BA,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,eAAe,mBAAO,CAAC,2DAAa;;AAEpC;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC1BA,uBAAuB,mBAAO,CAAC,2EAAqB;AACpD,gBAAgB,mBAAO,CAAC,6DAAc;AACtC,eAAe,mBAAO,CAAC,2DAAa;;AAEpC;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,GAAG;AACd,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC1BA,oBAAoB,mBAAO,CAAC,qEAAkB;AAC9C,eAAe,mBAAO,CAAC,2DAAa;AACpC,kBAAkB,mBAAO,CAAC,+DAAe;;AAEzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACpCA,oBAAoB,mBAAO,CAAC,qEAAkB;AAC9C,iBAAiB,mBAAO,CAAC,+DAAe;AACxC,kBAAkB,mBAAO,CAAC,+DAAe;;AAEzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,QAAQ;AACnB,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;UCjBA;UACA;;UAEA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;;UAEA;UACA;;UAEA;UACA;;UAEA;UACA;UACA;;;;;WCzBA;WACA;WACA;WACA;WACA,GAAG;WACH;WACA;WACA,CAAC;;;;;WCPD;WACA;WACA;WACA,uDAAuD,iBAAiB;WACxE;WACA,gDAAgD,aAAa;WAC7D;;;;;WCNA;WACA;WACA;WACA;WACA;;;;;;;;;;;;;ACHoC;AAEpC,IAAI,QAAgB,CAAC;AACrB,IAAI,WAAmB,CAAC;AACxB,IAAI,YAAkB,CAAC;AACvB,IAAI,WAAiB,CAAC;AACtB,MAAM,WAAW,GAAG,GAAG,8CAAG,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,SAAS,CAAC;AACrD,IAAI,aAAoC,CAAC;AACzC,IAAI,eAAwC,CAAC;AAC7C,IAAI,UAAgC,CAAC;AAErC,MAAM,CAAC,gBAAgB,CAAC,kBAAkB,EAAE,KAAK,IAAI,EAAE;IACtD,MAAM,QAAQ,GAAqB,8CAAG,CAAC,QAAQ,CAAC,cAAc,EAAE,CAAC;IACjE,MAAM,QAAQ,CAAC,IAAI,CAAC,oBAAoB,EAAE,KAAK,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC;IAC9D,8CAAG,CAAC,QAAQ,CAAC,IAAI,CAAC;QACjB,gBAAgB,EAAE,KAAK,EAAE,QAAQ,EAAE,EAAE;YACpC;;eAEG;YACH,MAAM,QAAS,SAAQ,QAAQ;aAAG;YAClC,OAAO,IAAI,QAAQ,EAAE,CAAC;QACvB,CAAC;KACD,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;AACpB,CAAC,CAAC,CAAC;AAEH;;GAEG;AACH,KAAK,UAAU,IAAI;IAClB,MAAM,cAAc,GAAG,QAAQ,CAAC,aAAa,CAAoB,WAAW,CAAC,CAAC;IAC9E,IAAI,cAAc,EAAE,CAAC;QACpB,MAAM,iBAAiB,CAAC,cAAc,CAAC,CAAC;QACxC,cAAc,CAAC,gBAAgB,CAAC,QAAQ,EAAE,KAAK,EAAE,oBAAoB,EAAE,EAAE;YACxE,QAAQ,GAAI,oBAAoB,CAAC,MAA4B,CAAC,KAAK,CAAC;QACrE,CAAC,CAAC,CAAC;IACJ,CAAC;IAED,MAAM,MAAM,GAAG,QAAQ,CAAC,aAAa,CAAkB,cAAc,CAAC,CAAC;IACvE,IAAI,MAAM,EAAE,CAAC;QACZ,MAAM,CAAC,gBAAgB,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAC;IAClD,CAAC;IAED,MAAM,aAAa,GAAG,QAAQ,CAAC,aAAa,CAAoB,eAAe,CAAC,CAAC;IACjF,IAAI,aAAa,EAAE,CAAC;QACnB,aAAa,CAAC,gBAAgB,CAAC,OAAO,EAAE,mBAAmB,CAAC,CAAC;IAC9D,CAAC;IAED,MAAM,cAAc,GAAG,QAAQ,CAAC,aAAa,CAAoB,gBAAgB,CAAC,CAAC;IACnF,IAAI,cAAc,EAAE,CAAC;QACpB,cAAc,CAAC,gBAAgB,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;IACxD,CAAC;IAED,MAAM,aAAa,GAAG,QAAQ,CAAC,aAAa,CAAoB,kBAAkB,CAAC,CAAC;IACpF,IAAI,aAAa,EAAE,CAAC;QACnB,aAAa,CAAC,gBAAgB,CAAC,OAAO,EAAE,iBAAiB,CAAC,CAAC;IAC5D,CAAC;IAED,MAAM,aAAa,GAAG,QAAQ,CAAC,aAAa,CAAoB,kBAAkB,CAAC,CAAC;IACpF,IAAI,aAAa,EAAE,CAAC;QACnB,aAAa,CAAC,gBAAgB,CAAC,OAAO,EAAE,iBAAiB,CAAC,CAAC;IAC5D,CAAC;IAED,MAAM,eAAe,GAAG,QAAQ,CAAC,aAAa,CAAoB,gBAAgB,CAAC,CAAC;IACpF,IAAI,eAAe,EAAE,CAAC;QACrB,eAAe,CAAC,gBAAgB,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;IACzD,CAAC;IAED,MAAM,4BAA4B,EAAE,CAAC;AACtC,CAAC;AAED;;GAEG;AACH,KAAK,UAAU,4BAA4B;IAC1C,8HAA8H;IAC9H,+CAA+C;IAC/C,IAAI,aAAa,KAAK,SAAS,IAAI,eAAe,KAAK,SAAS,EAAE,CAAC;QAClE,sDAAsD;QACtD,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;YAC9B,MAAM,IAAI,GAAG,MAAM,SAAS,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC;YACpD,4BAA4B;YAC5B,gFAAgF;YAChF,UAAU,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,SAAS,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;QACpE,CAAC;QACD,eAAe,GAAG,MAAM,8CAAG,CAAC,mBAAmB,CAAC,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;QAC5E,eAAe,CAAC,YAAY,CAAC,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE;YAClD,IAAI,QAAQ,CAAC,IAAI,KAAK,8CAAG,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;gBAC5C,oBAAoB;gBACpB,MAAM,IAAI,KAAK,CAAC,+EAA+E,CAAC,CAAC;YAClG,CAAC;YACD,2IAA2I;QAC5I,CAAC,CAAC,CAAC;QACH,eAAe,CAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,OAAgB,EAAE,QAAQ,EAAE,EAAE;YACpE,IAAI,QAAQ,CAAC,IAAI,KAAK,8CAAG,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;gBAC5C,8JAA8J;gBAC9J,MAAM,IAAI,KAAK,CAAC,6DAA6D,CAAC,CAAC;YAChF,CAAC;YACD,MAAM,UAAU,GAAG,QAAQ,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;YACtD,IAAI,CAAC;gBACJ,gHAAgH;gBAChH,gBAAgB;gBAChB,MAAM,YAAY,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;gBAC9C,MAAM,OAAO,GAAG,GAAG,YAAY,IAAI,QAAQ,CAAC,IAAI,IAAI,OAAO,EAAE,CAAC;gBAC9D,MAAM,cAAc,CAAC,OAAO,CAAC,CAAC;gBAC9B,IAAI,UAAU,EAAE,CAAC;oBAChB,UAAU,CAAC,WAAW,IAAI;;GAE5B,OAAO,GAAG,CAAC;gBACV,CAAC;YACF,CAAC;YAAC,OAAO,GAAY,EAAE,CAAC;gBACvB,IAAI,UAAU,EAAE,CAAC;oBAChB,UAAU,CAAC,WAAW,IAAI;qDACuB,GAAa,CAAC,OAAO,EAAE,CAAC;gBAC1E,CAAC;YACF,CAAC;QACF,CAAC,CAAC,CAAC;QACH,aAAa,GAAG,MAAM,8CAAG,CAAC,mBAAmB,CAAC,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;IAC5E,CAAC;AACF,CAAC;AAED;;;;GAIG;AACH,KAAK,UAAU,cAAc,CAAC,UAAkB;IAC/C,IAAI,CAAC;QACJ,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;YAC9B,MAAM,IAAI,GAAG,MAAM,SAAS,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC;YACpD,gDAAgD;YAChD,gFAAgF;YAChF,UAAU,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,SAAS,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;QACpE,CAAC;QACD,2BAA2B;QAC3B,MAAM,cAAc,GAAG,MAAM,UAAU,CAAC,cAAc,CAAC,EAAE,gBAAgB,EAAE,IAAI,EAAE,CAAC,CAAC;QAEnF,iDAAiD;QACjD,MAAM,WAAW,GAAG,MAAM,UAAU,CAAC,OAAO,EAAE,CAAC;QAC/C,MAAM,IAAI,GAAG,WAAW,CAAC,IAAI,CAAC;QAC9B,MAAM,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAEhC,oCAAoC;QACpC,IAAI,IAAI,KAAK,CAAC,EAAE,CAAC;YAChB,MAAM,cAAc,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;QACxC,CAAC;aAAM,CAAC;YACP,MAAM,cAAc,CAAC,KAAK,CAAC,KAAK,UAAU,EAAE,CAAC,CAAC;QAC/C,CAAC;QAED,iBAAiB;QACjB,MAAM,cAAc,CAAC,KAAK,EAAE,CAAC;QAE7B,OAAO,CAAC,GAAG,CAAC,mCAAmC,CAAC,CAAC;IAClD,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACd,OAAO,CAAC,KAAK,CAAC,4BAA4B,EAAE,GAAG,CAAC,CAAC;IAClD,CAAC;AACF,CAAC;AAED;;;;;;;GAOG;AACH,KAAK,UAAU,aAAa,CAAC,WAAkB;IAC9C,WAAW,CAAC,cAAc,EAAE,CAAC;IAC7B,IAAI,CAAC,QAAQ,EAAE,CAAC;QACf,QAAQ,GAAG,WAAW,CAAC;IACxB,CAAC;IACD,MAAM,QAAQ,GAAG,IAAI,QAAQ,EAAE,CAAC;IAChC,WAAW,GAAG,MAAM,cAAc,CAAC,QAAQ,CAAC,CAAC;IAC7C,YAAY,GAAG,IAAI,IAAI,CAAC,CAAC,WAAW,CAAC,EAAE,QAAQ,EAAE,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC,CAAC;IACzE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IACtC,QAAQ,CAAC,MAAM,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;IACtC,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,8CAAG,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC;IACrC,MAAM,UAAU,GAAG,QAAQ,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;IAEtD,IAAI,CAAC;QACJ,MAAM,WAAW,GAAG,MAAM,KAAK,CAAC,+BAA+B,EAAE;YAChE,MAAM,EAAE,MAAM;YACd,IAAI,EAAE,QAAQ;SACd,CAAC,CAAC;QACH,MAAM,eAAe,GAAG,MAAM,WAAW,CAAC,IAAI,EAAE,CAAC;QACjD,MAAM,qBAAqB,GAAG,IAAI,CAAC,SAAS,CAAC,eAAe,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;QACvE,MAAM,IAAI,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC,kBAAkB,EAAE,KAAK,qBAAqB,IAAI,CAAC;QAC9E,IAAI,UAAU,EAAE,CAAC;YAChB,UAAU,CAAC,WAAW,IAAI,IAAI,CAAC;QAChC,CAAC;IACF,CAAC;IAAC,OAAO,GAAY,EAAE,CAAC;QACvB,IAAI,UAAU,EAAE,CAAC;YAChB,UAAU,CAAC,WAAW,IAAI;gCACI,GAAa,CAAC,OAAO,EAAE,CAAC;QACvD,CAAC;IACF,CAAC;AACF,CAAC;AAED;;;GAGG;AACH,KAAK,UAAU,oBAAoB;IAClC,oDAAoD;IACpD,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;QAC9B,IAAI,CAAC;YACJ,gCAAgC;YAChC,MAAM,IAAI,GAAG,MAAM,UAAU,CAAC,OAAO,EAAE,CAAC;YACxC,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC;YAC9B,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC;YACvC,WAAW,GAAG,IAAI,IAAI,CAAC,CAAC,YAAY,CAAC,EAAE,WAAW,EAAE,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC,CAAC;YAC5E,MAAM,YAAY,GAAG,IAAI,QAAQ,EAAE,CAAC;YACpC,YAAY,CAAC,MAAM,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC;YAC7C,YAAY,CAAC,MAAM,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC;YAC7C,YAAY,CAAC,MAAM,CAAC,MAAM,EAAE,8CAAG,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC;YACzC,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,mCAAmC,EAAE;gBAC/D,MAAM,EAAE,MAAM;gBACd,IAAI,EAAE,YAAY;aAClB,CAAC,CAAC;YACH,IAAI,MAAM,CAAC,EAAE,EAAE,CAAC;gBACf,qCAAqC;gBACrC,MAAM,cAAc,GAAG,MAAM,UAAU,CAAC,cAAc,EAAE,CAAC;gBACzD,MAAM,cAAc,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;gBACjC,MAAM,cAAc,CAAC,KAAK,EAAE,CAAC;gBAE7B,MAAM,UAAU,GAAG,QAAQ,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;gBACtD,MAAM,eAAe,GAAG,MAAM,MAAM,CAAC,IAAI,EAAE,CAAC;gBAC5C,MAAM,qBAAqB,GAAG,IAAI,CAAC,SAAS,CAAC,eAAe,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;gBACvE,MAAM,IAAI,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC,kBAAkB,EAAE,KAAK,qBAAqB,IAAI,CAAC;gBAC9E,IAAI,UAAU,EAAE,CAAC;oBAChB,UAAU,CAAC,WAAW,IAAI,IAAI,CAAC;gBAChC,CAAC;gBACD,OAAO,IAAI,CAAC;YACb,CAAC;YACD,OAAO,KAAK,CAAC;QACd,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YAChB,OAAO,CAAC,KAAK,CAAC,yBAAyB,EAAE,KAAK,CAAC,CAAC;YAChD,OAAO,KAAK,CAAC;QACd,CAAC;IACF,CAAC;IACD,OAAO,KAAK,CAAC;AACd,CAAC;AAED;;GAEG;AACH,SAAS,YAAY;IACpB,MAAM,UAAU,GAAG,QAAQ,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;IACtD,IAAI,UAAU,EAAE,CAAC;QAChB,UAAU,CAAC,WAAW,GAAG,EAAE,CAAC;IAC7B,CAAC;AACF,CAAC;AAED;;GAEG;AACH,KAAK,UAAU,mBAAmB;IACjC,MAAM,UAAU,GAAG,QAAQ,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;IACtD,IAAI,CAAC;QACJ,MAAM,cAAc,GAAG,MAAM,8CAAG,CAAC,WAAW,CAAC,cAAc,EAAE,CAAC,kBAAkB,EAAE,CAAC;QACnF,IAAI,UAAU,EAAE,CAAC;YAChB,UAAU,CAAC,WAAW,IAAI;6BACA,cAAc,CAAC,KAAK,EAAE,CAAC;QAClD,CAAC;IACF,CAAC;IAAC,OAAO,GAAY,EAAE,CAAC;QACvB,IAAI,UAAU,EAAE,CAAC;YAChB,UAAU,CAAC,WAAW,IAAI;4BACA,GAAa,CAAC,OAAO,EAAE,CAAC;QACnD,CAAC;IACF,CAAC;AACF,CAAC;AAED;;GAEG;AACH,KAAK,UAAU,YAAY;IAC1B,MAAM,UAAU,GAAG,QAAQ,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;IACtD,IAAI,CAAC;QACJ,MAAM,OAAO,GAAG,MAAM,oBAAoB,EAAE,CAAC;QAC7C,IAAI,UAAU,EAAE,CAAC;YAChB,UAAU,CAAC,WAAW,IAAI;+BACE,OAAO,EAAE,CAAC;QACvC,CAAC;IACF,CAAC;IAAC,OAAO,GAAY,EAAE,CAAC;QACvB,IAAI,UAAU,EAAE,CAAC;YAChB,UAAU,CAAC,WAAW,IAAI;6BACC,GAAa,CAAC,OAAO,EAAE,CAAC;QACpD,CAAC;IACF,CAAC;AACF,CAAC;AAED;;GAEG;AACH,KAAK,UAAU,iBAAiB;IAC/B,MAAM,UAAU,GAAG,QAAQ,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;IACtD,IAAI,CAAC;QACJ,MAAM,OAAO,GAAG;+BACa,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC;QAC1C,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QACrB,IAAI,UAAU,EAAE,CAAC;YAChB,UAAU,CAAC,WAAW,IAAI;;GAE1B,OAAO,GAAG,CAAC;QACZ,CAAC;IACF,CAAC;IAAC,OAAO,GAAY,EAAE,CAAC;QACvB,IAAI,UAAU,EAAE,CAAC;YAChB,UAAU,CAAC,WAAW,IAAI;iCACK,GAAa,CAAC,OAAO,EAAE,CAAC;QACxD,CAAC;IACF,CAAC;AACF,CAAC;AAED;;GAEG;AACH,KAAK,UAAU,iBAAiB;IAC/B,MAAM,UAAU,GAAG,QAAQ,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;IACtD,IAAI,CAAC;QACJ,MAAM,OAAO,GAAG;+BACa,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC;QAC1C,IAAI,UAAU,EAAE,CAAC;YAChB,UAAU,CAAC,WAAW,IAAI;;GAE1B,OAAO,GAAG,CAAC;QACZ,CAAC;QACD,MAAM,aAAa,CAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAC9C,CAAC;IAAC,OAAO,GAAY,EAAE,CAAC;QACvB,IAAI,UAAU,EAAE,CAAC;YAChB,UAAU,CAAC,WAAW,IAAI;6CACiB,GAAa,CAAC,OAAO,EAAE,CAAC;QACpE,CAAC;IACF,CAAC;AACF,CAAC;AAED;;;;GAIG;AACH,KAAK,UAAU,cAAc,CAAC,IAAY;IACzC,MAAM,GAAG,GAAG,MAAM,8CAAG,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;IAC9C,OAAO,GAAG,CAAC;AACZ,CAAC;AAED;;;GAGG;AACH,KAAK,UAAU,iBAAiB,CAAC,aAAgC;IAChE,MAAM,OAAO,GAAsB,MAAM,8CAAG,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;IAEjE,KAAK,MAAM,GAAG,IAAI,OAAO,EAAE,CAAC;QAC3B,MAAM,UAAU,GAAsB,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;QACvE,UAAU,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,CAAC;QACzB,UAAU,CAAC,WAAW,GAAG,GAAG,CAAC,IAAI,CAAC;QAClC,UAAU,CAAC,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC;QAC5B,aAAa,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;IAClC,CAAC;AACF,CAAC","sources":["webpack://use-logging-apis/../../node_modules/@openfin/core/out/mock.js","webpack://use-logging-apis/../../node_modules/events/events.js","webpack://use-logging-apis/../../node_modules/lodash/_DataView.js","webpack://use-logging-apis/../../node_modules/lodash/_Hash.js","webpack://use-logging-apis/../../node_modules/lodash/_ListCache.js","webpack://use-logging-apis/../../node_modules/lodash/_Map.js","webpack://use-logging-apis/../../node_modules/lodash/_MapCache.js","webpack://use-logging-apis/../../node_modules/lodash/_Promise.js","webpack://use-logging-apis/../../node_modules/lodash/_Set.js","webpack://use-logging-apis/../../node_modules/lodash/_SetCache.js","webpack://use-logging-apis/../../node_modules/lodash/_Stack.js","webpack://use-logging-apis/../../node_modules/lodash/_Symbol.js","webpack://use-logging-apis/../../node_modules/lodash/_Uint8Array.js","webpack://use-logging-apis/../../node_modules/lodash/_WeakMap.js","webpack://use-logging-apis/../../node_modules/lodash/_arrayEach.js","webpack://use-logging-apis/../../node_modules/lodash/_arrayFilter.js","webpack://use-logging-apis/../../node_modules/lodash/_arrayLikeKeys.js","webpack://use-logging-apis/../../node_modules/lodash/_arrayPush.js","webpack://use-logging-apis/../../node_modules/lodash/_arraySome.js","webpack://use-logging-apis/../../node_modules/lodash/_assignValue.js","webpack://use-logging-apis/../../node_modules/lodash/_assocIndexOf.js","webpack://use-logging-apis/../../node_modules/lodash/_baseAssign.js","webpack://use-logging-apis/../../node_modules/lodash/_baseAssignIn.js","webpack://use-logging-apis/../../node_modules/lodash/_baseAssignValue.js","webpack://use-logging-apis/../../node_modules/lodash/_baseClone.js","webpack://use-logging-apis/../../node_modules/lodash/_baseCreate.js","webpack://use-logging-apis/../../node_modules/lodash/_baseGetAllKeys.js","webpack://use-logging-apis/../../node_modules/lodash/_baseGetTag.js","webpack://use-logging-apis/../../node_modules/lodash/_baseIsArguments.js","webpack://use-logging-apis/../../node_modules/lodash/_baseIsEqual.js","webpack://use-logging-apis/../../node_modules/lodash/_baseIsEqualDeep.js","webpack://use-logging-apis/../../node_modules/lodash/_baseIsMap.js","webpack://use-logging-apis/../../node_modules/lodash/_baseIsNative.js","webpack://use-logging-apis/../../node_modules/lodash/_baseIsSet.js","webpack://use-logging-apis/../../node_modules/lodash/_baseIsTypedArray.js","webpack://use-logging-apis/../../node_modules/lodash/_baseKeys.js","webpack://use-logging-apis/../../node_modules/lodash/_baseKeysIn.js","webpack://use-logging-apis/../../node_modules/lodash/_baseTimes.js","webpack://use-logging-apis/../../node_modules/lodash/_baseUnary.js","webpack://use-logging-apis/../../node_modules/lodash/_cacheHas.js","webpack://use-logging-apis/../../node_modules/lodash/_cloneArrayBuffer.js","webpack://use-logging-apis/../../node_modules/lodash/_cloneBuffer.js","webpack://use-logging-apis/../../node_modules/lodash/_cloneDataView.js","webpack://use-logging-apis/../../node_modules/lodash/_cloneRegExp.js","webpack://use-logging-apis/../../node_modules/lodash/_cloneSymbol.js","webpack://use-logging-apis/../../node_modules/lodash/_cloneTypedArray.js","webpack://use-logging-apis/../../node_modules/lodash/_copyArray.js","webpack://use-logging-apis/../../node_modules/lodash/_copyObject.js","webpack://use-logging-apis/../../node_modules/lodash/_copySymbols.js","webpack://use-logging-apis/../../node_modules/lodash/_copySymbolsIn.js","webpack://use-logging-apis/../../node_modules/lodash/_coreJsData.js","webpack://use-logging-apis/../../node_modules/lodash/_defineProperty.js","webpack://use-logging-apis/../../node_modules/lodash/_equalArrays.js","webpack://use-logging-apis/../../node_modules/lodash/_equalByTag.js","webpack://use-logging-apis/../../node_modules/lodash/_equalObjects.js","webpack://use-logging-apis/../../node_modules/lodash/_freeGlobal.js","webpack://use-logging-apis/../../node_modules/lodash/_getAllKeys.js","webpack://use-logging-apis/../../node_modules/lodash/_getAllKeysIn.js","webpack://use-logging-apis/../../node_modules/lodash/_getMapData.js","webpack://use-logging-apis/../../node_modules/lodash/_getNative.js","webpack://use-logging-apis/../../node_modules/lodash/_getPrototype.js","webpack://use-logging-apis/../../node_modules/lodash/_getRawTag.js","webpack://use-logging-apis/../../node_modules/lodash/_getSymbols.js","webpack://use-logging-apis/../../node_modules/lodash/_getSymbolsIn.js","webpack://use-logging-apis/../../node_modules/lodash/_getTag.js","webpack://use-logging-apis/../../node_modules/lodash/_getValue.js","webpack://use-logging-apis/../../node_modules/lodash/_hashClear.js","webpack://use-logging-apis/../../node_modules/lodash/_hashDelete.js","webpack://use-logging-apis/../../node_modules/lodash/_hashGet.js","webpack://use-logging-apis/../../node_modules/lodash/_hashHas.js","webpack://use-logging-apis/../../node_modules/lodash/_hashSet.js","webpack://use-logging-apis/../../node_modules/lodash/_initCloneArray.js","webpack://use-logging-apis/../../node_modules/lodash/_initCloneByTag.js","webpack://use-logging-apis/../../node_modules/lodash/_initCloneObject.js","webpack://use-logging-apis/../../node_modules/lodash/_isIndex.js","webpack://use-logging-apis/../../node_modules/lodash/_isKeyable.js","webpack://use-logging-apis/../../node_modules/lodash/_isMasked.js","webpack://use-logging-apis/../../node_modules/lodash/_isPrototype.js","webpack://use-logging-apis/../../node_modules/lodash/_listCacheClear.js","webpack://use-logging-apis/../../node_modules/lodash/_listCacheDelete.js","webpack://use-logging-apis/../../node_modules/lodash/_listCacheGet.js","webpack://use-logging-apis/../../node_modules/lodash/_listCacheHas.js","webpack://use-logging-apis/../../node_modules/lodash/_listCacheSet.js","webpack://use-logging-apis/../../node_modules/lodash/_mapCacheClear.js","webpack://use-logging-apis/../../node_modules/lodash/_mapCacheDelete.js","webpack://use-logging-apis/../../node_modules/lodash/_mapCacheGet.js","webpack://use-logging-apis/../../node_modules/lodash/_mapCacheHas.js","webpack://use-logging-apis/../../node_modules/lodash/_mapCacheSet.js","webpack://use-logging-apis/../../node_modules/lodash/_mapToArray.js","webpack://use-logging-apis/../../node_modules/lodash/_nativeCreate.js","webpack://use-logging-apis/../../node_modules/lodash/_nativeKeys.js","webpack://use-logging-apis/../../node_modules/lodash/_nativeKeysIn.js","webpack://use-logging-apis/../../node_modules/lodash/_nodeUtil.js","webpack://use-logging-apis/../../node_modules/lodash/_objectToString.js","webpack://use-logging-apis/../../node_modules/lodash/_overArg.js","webpack://use-logging-apis/../../node_modules/lodash/_root.js","webpack://use-logging-apis/../../node_modules/lodash/_setCacheAdd.js","webpack://use-logging-apis/../../node_modules/lodash/_setCacheHas.js","webpack://use-logging-apis/../../node_modules/lodash/_setToArray.js","webpack://use-logging-apis/../../node_modules/lodash/_stackClear.js","webpack://use-logging-apis/../../node_modules/lodash/_stackDelete.js","webpack://use-logging-apis/../../node_modules/lodash/_stackGet.js","webpack://use-logging-apis/../../node_modules/lodash/_stackHas.js","webpack://use-logging-apis/../../node_modules/lodash/_stackSet.js","webpack://use-logging-apis/../../node_modules/lodash/_toSource.js","webpack://use-logging-apis/../../node_modules/lodash/cloneDeep.js","webpack://use-logging-apis/../../node_modules/lodash/eq.js","webpack://use-logging-apis/../../node_modules/lodash/isArguments.js","webpack://use-logging-apis/../../node_modules/lodash/isArray.js","webpack://use-logging-apis/../../node_modules/lodash/isArrayLike.js","webpack://use-logging-apis/../../node_modules/lodash/isBuffer.js","webpack://use-logging-apis/../../node_modules/lodash/isEqual.js","webpack://use-logging-apis/../../node_modules/lodash/isFunction.js","webpack://use-logging-apis/../../node_modules/lodash/isLength.js","webpack://use-logging-apis/../../node_modules/lodash/isMap.js","webpack://use-logging-apis/../../node_modules/lodash/isObject.js","webpack://use-logging-apis/../../node_modules/lodash/isObjectLike.js","webpack://use-logging-apis/../../node_modules/lodash/isSet.js","webpack://use-logging-apis/../../node_modules/lodash/isTypedArray.js","webpack://use-logging-apis/../../node_modules/lodash/keys.js","webpack://use-logging-apis/../../node_modules/lodash/keysIn.js","webpack://use-logging-apis/../../node_modules/lodash/stubArray.js","webpack://use-logging-apis/../../node_modules/lodash/stubFalse.js","webpack://use-logging-apis/webpack/bootstrap","webpack://use-logging-apis/webpack/runtime/global","webpack://use-logging-apis/webpack/runtime/make namespace object","webpack://use-logging-apis/webpack/runtime/node module decorator","webpack://use-logging-apis/./client/src/provider.ts"],"sourcesContent":["'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar require$$0 = require('events');\nvar require$$0$1 = require('lodash/cloneDeep');\nvar require$$3 = require('lodash/isEqual');\n\nfunction _mergeNamespaces(n, m) {\n\tm.forEach(function (e) {\n\t\te && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {\n\t\t\tif (k !== 'default' && !(k in n)) {\n\t\t\t\tvar d = Object.getOwnPropertyDescriptor(e, k);\n\t\t\t\tObject.defineProperty(n, k, d.get ? d : {\n\t\t\t\t\tenumerable: true,\n\t\t\t\t\tget: function () { return e[k]; }\n\t\t\t\t});\n\t\t\t}\n\t\t});\n\t});\n\treturn Object.freeze(n);\n}\n\nvar commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};\n\nfunction getDefaultExportFromCjs (x) {\n\treturn x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;\n}\n\nvar OpenFin$2 = {};\n\nvar events = {};\n\nvar application$1 = {};\n\n/**\n * Namespace for events that can be emitted by an {@link OpenFin.Application}.  Includes events\n * re-propagated from the {@link OpenFin.Window} (and, transitively, {@link OpenFin.View}) level, prefixed with `window-` (and also, if applicable, `view-`).\n * For example, a view's \"attached\" event will fire as 'window-view-attached' at the application level.\n *\n * Event payloads are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.\n * Events gain metadata as they propagate, which is *not* present on the explicit payload interfaces.  To refer to the full type\n * of an event as it would be raised on this emitter, use {@link Payload}.\n *\n * This namespace contains only payload shapes for events that are unique to `Application`.  Events that propagate to `Application` from\n * child {@link OpenFin.Window windows} and {@link OpenFin.View views} are defined in the {@link OpenFin.WindowEvents} and\n * {@link OpenFin.ViewEvents} namespaces.  For a list of valid string keys for *all* application events, see {@link Application.on Application.on}.\n *\n * {@link ApplicationSourcedEvent Application-sourced events} (i.e. those that have not propagated from {@link OpenFin.ViewEvents Views}\n * or {@link OpenFin.WindowEvents Windows} re-propagate to {@link OpenFin.SystemEvents System} with their type string prefixed with `application-`.\n * {@link ApplicationWindowEvent Application events that are tied to Windows but do not propagate from them}\n * are propagated to `System` without any type string prefixing.\n *\n * \"Requested\" events (e.g. {@link RunRequestedEvent}) do not propagate.\n *\n * @packageDocumentation\n */\nObject.defineProperty(application$1, \"__esModule\", { value: true });\n\nvar base$1 = {};\n\n/**\n * Namespace for shared event payloads and utility types common to all event emitters.\n *\n * @packageDocumentation\n */\nObject.defineProperty(base$1, \"__esModule\", { value: true });\n\nvar externalApplication$1 = {};\n\n/**\n * Namespace for events that can be transmitted by an {@link OpenFin.ExternalApplication}.\n *\n * Event payloads are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.\n * Events gain metadata as they propagate, which is *not* present on the explicit payload interfaces.  To refer to the full type\n * of an event as it would be raised on this emitter, use {@link Payload}.\n *\n * For a list of valid string keys for external application events, see {@link ExternalApplication.on ExternalApplication.on}.\n *\n * @packageDocumentation\n */\nObject.defineProperty(externalApplication$1, \"__esModule\", { value: true });\n\nvar frame$1 = {};\n\nObject.defineProperty(frame$1, \"__esModule\", { value: true });\n\nvar globalHotkey$1 = {};\n\n/**\n *\n * Namespace for events that can be transmitted by {@link GlobalHotkey.GlobalHotkey}.\n *\n * Event payloads are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.\n * Events gain metadata as they propagate, which is *not* present on the explicit payload interfaces.  To refer to the full type\n * of an event as it would be raised on this emitter, use {@link Payload}.\n *\n * For a list of valid string keys for global hotkey events, see {@link GlobalHotkey.GlobalHotkey.on GlobalHotkey.on}.\n *\n * @packageDocumentation\n */\nObject.defineProperty(globalHotkey$1, \"__esModule\", { value: true });\n\nvar platform$1 = {};\n\n/**\n *\n * Namespace for events that can emitted by a {@link OpenFin.Platform}.\n *\n * Event payloads are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.\n * Events gain metadata as they propagate, which is *not* present on the explicit payload interfaces.  To refer to the full type\n * of an event as it would be raised on this emitter, use {@link Payload}.\n *\n * The Platform `EventEmitter` is a superset of the {@link OpenFin.Application} `EventEmitter`,\n * meaning it can listen to all {@link OpenFin.ApplicationEvents Application events} in addition to the\n * Platform-specific events listed here.  For a list of valid string keys for *all* platform events, see\n * {@link Platform.on Platform.on}.\n *\n * @packageDocumentation\n */\nObject.defineProperty(platform$1, \"__esModule\", { value: true });\n\nvar system$1 = {};\n\n/**\n * Namespace for runtime-wide OpenFin events emitted by {@link System.System}.  Includes events\n * re-propagated from {@link OpenFin.Application}, {@link OpenFin.Window}, and {@link OpenFin.View} (prefixed with `application-`, `window-`, and `view-`).  All\n * event propagations are visible at the System level. Propagated events from WebContents (windows, views, frames) to the Application level will *not*\n * transitively re-propagate to the System level, because they are already visible at the system level and contain the identity\n * of the application.  For example, an application's \"closed\" event will fire as 'application-closed' at the system level.  A view's 'shown' event\n * will be visible as 'view-shown' at the system level, but *not* as `application-window-view-shown`.\n *\n * Event payloads are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.\n * Events gain metadata as they propagate, which is *not* present on the explicit payload interfaces.  To refer to the full type\n * of an event as it would be raised on this emitter, use {@link Payload}.\n *\n * This namespace contains only payload shapes for events that are unique to `System`.  Events that propagate to `System` from\n * child {@link OpenFin.Application applications}, {@link OpenFin.Window windows}, and {@link OpenFin.View views} are defined in the\n * {@link OpenFin.ApplicationEvents}, {@link OpenFin.WindowEvents}, and {@link OpenFin.ViewEvents} namespaces.  For a list of valid string keys for *all*\n * system events, see {@link System.on System.on}.\n *\n * @packageDocumentation\n */\nObject.defineProperty(system$1, \"__esModule\", { value: true });\n\nvar view$1 = {};\n\n/**\n * Namespace for events that can be emitted by a {@link OpenFin.View}.\n *\n * Event payloads are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.\n * Events gain metadata as they propagate, which is *not* present on the explicit payload interfaces.  To refer to the full type\n * of an event as it would be raised on this emitter, use {@link Payload}.\n *\n * This namespace contains only payload shapes for events that are unique to `View`.  Events that are shared between all `WebContents`\n * (i.e. {@link OpenFin.Window}, {@link OpenFin.View}) are defined in {@link OpenFin.WebContentsEvents}.  For a list\n * of valid string keys for *all* View events, see {@link View.on View.on}.\n *\n * View events propagate to their parent {@link OpenFin.WindowEvents Window}, {@link OpenFin.ApplicationEvents Application},\n * and {@link OpenFin.SystemEvents System} with an added `viewIdentity` property and their event types prefixed with `'view-'`.\n *\n * @packageDocumentation\n */\nObject.defineProperty(view$1, \"__esModule\", { value: true });\n\nvar webcontents = {};\n\n/**\n * Namespace for events shared by all OpenFin WebContents elements (i.e. {@link OpenFin.Window},\n * {@link OpenFin.View}).\n *\n * WebContents events will re-emit on parent entities - e.g., a propagating event in a view will also be emitted on the view's\n * parent window, and propagating events in a window will also be emitted on the window's parent {@link OpenFin.Application}.\n *\n * @packageDocumentation\n */\nObject.defineProperty(webcontents, \"__esModule\", { value: true });\n\nvar window$2 = {};\n\n/**\n * Namespace for events that can be emitted by a {@link OpenFin.Window}.\n *\n * Event payloads are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.\n * Events gain metadata as they propagate, which is *not* present on the explicit payload interfaces.  To refer to the full type\n * of an event as it would be raised on this emitter, use {@link Payload}.\n *\n * This namespace contains only payload shapes for events that are unique to `Window`.  Events that are shared between all `WebContents`\n * (i.e. {@link OpenFin.Window}, {@link OpenFin.View}) are defined in {@link OpenFin.WebContentsEvents}. Events that\n * propagate from `View` are defined in {@link OpenFin.ViewEvents}. For a list of valid string keys for *all* Window events, see\n * {@link Window.on Window.on}\n *\n * {@link OpenFin.WindowEvents.WindowSourcedEvent Window-sourced events} (i.e. those that are not propagated from a\n * {@link OpenFin.ViewEvents View}) propagate to their parent {@link OpenFin.ApplicationEvents Application} and\n * {@link OpenFin.SystemEvents System} with their event types prefixed with `'window-'`).\n *\n * \"Requested\" events (e.g. {@link AuthRequestedEvent}) do not propagate to `System.  The {@link OpenFin.WindowEvents.WindowCloseRequestedEvent}\n * does not propagate at all.\n *\n * @packageDocumentation\n */\nObject.defineProperty(window$2, \"__esModule\", { value: true });\n\n/**\n * Namespace for OpenFin event types. Each entity that emits OpenFin events has its own sub-namespace. Event payloads\n * themselves are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.\n *\n * #### Event emitters\n *\n * The following entities emit OpenFin events, and have corresponding sub-namespaces:\n *\n * * {@link OpenFin.Application}: {@link OpenFin.ApplicationEvents}\n * * {@link OpenFin.ExternalApplication}: {@link OpenFin.ExternalApplicationEvents}\n * * {@link OpenFin.Frame}: {@link OpenFin.FrameEvents}\n * * {@link OpenFin.GlobalHotkey}: {@link OpenFin.GlobalHotkeyEvents}\n * * {@link OpenFin.Platform}: {@link OpenFin.PlatformEvents}\n * * {@link OpenFin.System}: {@link OpenFin.SystemEvents}\n * * {@link OpenFin.View}: {@link OpenFin.ViewEvents}\n * * {@link OpenFin.Window}: {@link OpenFin.WindowEvents}\n *\n * These `EventEmitter` entities share a common set of methods for interacting with the OpenFin event bus, which can be\n * seen on the individual documentation pages for each entity type.\n *\n * Registering event handlers is an asynchronous operation. It is important to ensure that the returned Promises are awaited to reduce the\n * risk of race conditions.\n *\n * When the `EventEmitter` receives an event from the browser process and emits on the renderer, all of the functions attached to that\n * specific event are called synchronously. Any values returned by the called listeners are ignored and will be discarded.  If the window document\n * is destroyed by page navigation or reload, its registered event listeners will be removed.\n *\n * We recommend using Arrow Functions for event listeners to ensure the this scope is consistent with the original function context.\n *\n * Events re-propagate from smaller/more-local scopes to larger/more-global scopes.  For example, an event emitted on a specific\n * view will propagate to the window in which the view is embedded, and then to the application in which the window is running, and\n * finally to the OpenFin runtime itself at the \"system\" level.  For details on propagation semantics, see the namespace for\n * the propagating (or propagated-to) entity.\n *\n * If you need the payload type for a specific type of event (especially propagated events), use the emitting topic's `Payload` generic\n * (e.g. {@link WindowEvents.Payload}) with the event's `type` string.  For example, the payload of\n * a {@link ViewEvents.CreatedEvent} after it has propagated to its parent {@link WindowEvents Window} can be found with\n * `WindowEvents.Payload<'view-created'>`.\n *\n * @packageDocumentation\n */\nvar __createBinding$1 = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault$1 = (commonjsGlobal && commonjsGlobal.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar$1 = (commonjsGlobal && commonjsGlobal.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding$1(result, mod, k);\n    __setModuleDefault$1(result, mod);\n    return result;\n};\nObject.defineProperty(events, \"__esModule\", { value: true });\nevents.WindowEvents = events.WebContentsEvents = events.ViewEvents = events.SystemEvents = events.PlatformEvents = events.GlobalHotkeyEvents = events.FrameEvents = events.ExternalApplicationEvents = events.BaseEvents = events.ApplicationEvents = void 0;\nconst ApplicationEvents = __importStar$1(application$1);\nevents.ApplicationEvents = ApplicationEvents;\nconst BaseEvents = __importStar$1(base$1);\nevents.BaseEvents = BaseEvents;\nconst ExternalApplicationEvents = __importStar$1(externalApplication$1);\nevents.ExternalApplicationEvents = ExternalApplicationEvents;\nconst FrameEvents = __importStar$1(frame$1);\nevents.FrameEvents = FrameEvents;\nconst GlobalHotkeyEvents = __importStar$1(globalHotkey$1);\nevents.GlobalHotkeyEvents = GlobalHotkeyEvents;\nconst PlatformEvents = __importStar$1(platform$1);\nevents.PlatformEvents = PlatformEvents;\nconst SystemEvents = __importStar$1(system$1);\nevents.SystemEvents = SystemEvents;\nconst ViewEvents = __importStar$1(view$1);\nevents.ViewEvents = ViewEvents;\nconst WebContentsEvents = __importStar$1(webcontents);\nevents.WebContentsEvents = WebContentsEvents;\nconst WindowEvents = __importStar$1(window$2);\nevents.WindowEvents = WindowEvents;\n\n(function (exports) {\n\t/**\n\t * Top-level namespace for types referenced by the OpenFin API.  Contains:\n\t *\n\t * * The type of the global `fin` entry point ({@link FinApi})\n\t * * Classes that act as static namespaces returned from the `fin` global (e.g. {@link ApplicationModule}, accessible via `fin.Application`)\n\t * * Instance classes that are returned from API calls (e.g. {@link Application}, accessible via `fin.Application.getCurrentSync()`)\n\t * * Parameter shapes for API methods (e.g. {@link ApplicationOptions}, used in `fin.Application.start()`)\n\t * * Event namespaces and payload union types (e.g. {@link ApplicationEvents} and {@link ApplicationEvent})\n\t *\n\t * @packageDocumentation\n\t */\n\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t    }\n\t    Object.defineProperty(o, k2, desc);\n\t}) : (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    o[k2] = m[k];\n\t}));\n\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t};\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t// Deprecated shim to preserve v30 namespace names\n\t__exportStar(events, exports); \n} (OpenFin$2));\n\nvar OpenFin = /*@__PURE__*/getDefaultExportFromCjs(OpenFin$2);\n\nvar OpenFin$1 = /*#__PURE__*/_mergeNamespaces({\n\t__proto__: null,\n\tdefault: OpenFin\n}, [OpenFin$2]);\n\nvar fin$2 = {};\n\nvar system = {};\n\nvar base = {};\n\nvar promises = {};\n\nObject.defineProperty(promises, \"__esModule\", { value: true });\npromises.promiseMapSerial = promises.serial = promises.promiseMap = promises.promisify = void 0;\nfunction promisify(func) {\n    return (...args) => new Promise((resolve, reject) => {\n        func(...args, (err, val) => (err ? reject(err) : resolve(val)));\n    });\n}\npromises.promisify = promisify;\nasync function promiseMap(arr, asyncF) {\n    return Promise.all(arr.map(asyncF));\n}\npromises.promiseMap = promiseMap;\nasync function serial(arr) {\n    const ret = [];\n    for (const func of arr) {\n        // eslint-disable-next-line no-await-in-loop\n        const next = await func();\n        ret.push(next);\n    }\n    return ret;\n}\npromises.serial = serial;\nasync function promiseMapSerial(arr, func) {\n    return serial(arr.map((value, index, array) => () => func(value, index, array)));\n}\npromises.promiseMapSerial = promiseMapSerial;\n\nvar __classPrivateFieldSet$c = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar __classPrivateFieldGet$e = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar _EmitterBase_emitterAccessor;\nObject.defineProperty(base, \"__esModule\", { value: true });\nbase.Reply = base.EmitterBase = base.Base = void 0;\nconst promises_1 = promises;\nclass Base {\n    /**\n     * @internal\n     */\n    constructor(wire) {\n        /**\n         * @internal\n         * @deprecated\n         */\n        this.isNodeEnvironment = () => {\n            return this.wire.environment.type === 'node';\n        };\n        /**\n         * @internal\n         * @deprecated\n         */\n        this.isOpenFinEnvironment = () => {\n            return this.wire.environment.type === 'openfin';\n        };\n        /**\n         * @internal\n         * @deprecated\n         */\n        this.isBrowserEnvironment = () => {\n            return this.wire.environment.type === 'other';\n        };\n        this.wire = wire;\n    }\n    get fin() {\n        return this.wire.getFin();\n    }\n    /**\n     * Provides access to the OpenFin representation of the current code context (usually a document\n     * such as a {@link OpenFin.View} or {@link OpenFin.Window}), as well as to the current `Interop` context.\n     *\n     * Useful for debugging in the devtools console, where this will intelligently type itself based\n     * on the context in which the devtools panel was opened.\n     */\n    get me() {\n        return this.wire.me;\n    }\n}\nbase.Base = Base;\n/**\n * An entity that emits OpenFin events.\n *\n * @remarks Event-binding methods are asynchronous as they must cross process boundaries\n * and setup the listener in the browser process.  When the `EventEmitter` receives an event from the browser process\n * and emits on the renderer, all of the functions attached to that specific event are called synchronously.  Any values\n * returned by the called listeners are ignored and will be discarded.  If the execution context of the window is destroyed\n * by page navigation or reload, any events that have been setup in that context will be destroyed.\n *\n * It is important to keep in mind that when an ordinary listener function is called, the standard `this` keyword is intentionally\n * set to reference the `EventEmitter` instance to which the listener is attached.  It is possible to use ES6 Arrow Functions as\n * listeners, however, when doing so, the `this` keyword will no longer reference the `EventEmitter` instance.\n *\n * Events re-propagate from smaller/more-local scopes to larger/more-global scopes.  For example, an event emitted on a specific\n * view will propagate to the window in which the view is embedded, and then to the application in which the window is running, and\n * finally to the OpenFin runtime itself at the \"system\" level.  Re-propagated events are prefixed with the name of the scope in which\n * they originated - for example, a \"shown\" event emitted on a view will be re-propagated at the window level as \"view-shown\", and\n * then to the application as \"window-view-shown\", and finally at the system level as \"application-window-view-shown\".\n *\n * All event propagations are visible at the System level, regardless of source, so transitive re-propagations (e.g. from view to window\n * to application) are visible in their entirety at the system level.  So, we can listen to the above event as \"shown\", \"view-shown\",\n * \"window-view-shown\", or \"application-window-view-shown.\"\n */\nclass EmitterBase extends Base {\n    constructor(wire, topic, ...additionalAccessors) {\n        super(wire);\n        this.topic = topic;\n        _EmitterBase_emitterAccessor.set(this, void 0);\n        this.eventNames = () => (this.hasEmitter() ? this.getOrCreateEmitter().eventNames() : []);\n        /**\n         * @internal\n         */\n        this.emit = (eventType, payload, ...args) => {\n            return this.hasEmitter() ? this.getOrCreateEmitter().emit(eventType, payload, ...args) : false;\n        };\n        this.hasEmitter = () => this.wire.eventAggregator.has(__classPrivateFieldGet$e(this, _EmitterBase_emitterAccessor, \"f\"));\n        this.getOrCreateEmitter = () => this.wire.eventAggregator.getOrCreate(__classPrivateFieldGet$e(this, _EmitterBase_emitterAccessor, \"f\"));\n        this.listeners = (type) => this.hasEmitter() ? this.getOrCreateEmitter().listeners(type) : [];\n        this.listenerCount = (type) => this.hasEmitter() ? this.getOrCreateEmitter().listenerCount(type) : 0;\n        this.registerEventListener = async (eventType, options = {}, applySubscription, undoSubscription) => {\n            const runtimeEvent = {\n                ...this.identity,\n                timestamp: options.timestamp || Date.now(),\n                topic: this.topic,\n                type: eventType\n            };\n            const emitter = this.getOrCreateEmitter();\n            // We apply the subscription and then undo if the async call fails to avoid\n            // indeterminacy in subscription application order, which can break things elsewhere\n            applySubscription(emitter);\n            try {\n                await this.wire.sendAction('subscribe-to-desktop-event', runtimeEvent);\n            }\n            catch (e) {\n                undoSubscription(emitter);\n                this.deleteEmitterIfNothingRegistered(emitter);\n                throw e;\n            }\n        };\n        this.deregisterEventListener = async (eventType, options = {}) => {\n            if (this.hasEmitter()) {\n                const runtimeEvent = {\n                    ...this.identity,\n                    timestamp: options.timestamp || Date.now(),\n                    topic: this.topic,\n                    type: eventType\n                };\n                await this.wire.sendAction('unsubscribe-to-desktop-event', runtimeEvent).catch(() => null);\n                const emitter = this.getOrCreateEmitter();\n                return emitter;\n            }\n            // This will only be reached if unsubscribe from event that does not exist but do not want to error here\n            return Promise.resolve();\n        };\n        __classPrivateFieldSet$c(this, _EmitterBase_emitterAccessor, [topic, ...additionalAccessors], \"f\");\n        this.listeners = (event) => this.hasEmitter() ? this.getOrCreateEmitter().listeners(event) : [];\n    }\n    /**\n     * Adds a listener to the end of the listeners array for the specified event.\n     *\n     * @remarks Event payloads are documented in the {@link OpenFin.Events} namespace.\n     */\n    async on(eventType, listener, options) {\n        await this.registerEventListener(eventType, options, (emitter) => {\n            emitter.on(eventType, listener);\n        }, (emitter) => {\n            emitter.removeListener(eventType, listener);\n        });\n        return this;\n    }\n    /**\n     * Adds a listener to the end of the listeners array for the specified event.\n     */\n    async addListener(eventType, listener, options) {\n        return this.on(eventType, listener, options);\n    }\n    /**\n     * Adds a one time listener for the event. The listener is invoked only the first time the event is fired, after which it is removed.\n     *\n     * @remarks Event payloads are documented in the {@link OpenFin.Events} namespace.\n     */\n    async once(eventType, listener, options) {\n        const deregister = () => this.deregisterEventListener(eventType);\n        await this.registerEventListener(eventType, options, (emitter) => {\n            emitter.once(eventType, deregister);\n            emitter.once(eventType, listener);\n        }, (emitter) => {\n            emitter.removeListener(eventType, deregister);\n            emitter.removeListener(eventType, listener);\n        });\n        return this;\n    }\n    /**\n     * Adds a listener to the beginning of the listeners array for the specified event.\n     *\n     * @remarks Event payloads are documented in the {@link OpenFin.Events} namespace.\n     */\n    async prependListener(eventType, listener, options) {\n        await this.registerEventListener(eventType, options, (emitter) => {\n            emitter.prependListener(eventType, listener);\n        }, (emitter) => {\n            emitter.removeListener(eventType, listener);\n        });\n        return this;\n    }\n    /**\n     * Adds a one time listener for the event. The listener is invoked only the first time the event is fired,\n     * after which it is removed. The listener is added to the beginning of the listeners array.\n     *\n     * @remarks Event payloads are documented in the {@link OpenFin.Events} namespace.\n     */\n    async prependOnceListener(eventType, listener, options) {\n        const deregister = () => this.deregisterEventListener(eventType);\n        await this.registerEventListener(eventType, options, (emitter) => {\n            emitter.prependOnceListener(eventType, listener);\n            emitter.once(eventType, deregister);\n        }, (emitter) => {\n            emitter.removeListener(eventType, listener);\n            emitter.removeListener(eventType, deregister);\n        });\n        return this;\n    }\n    /**\n     * Remove a listener from the listener array for the specified event.\n     *\n     * @remarks Caution: Calling this method changes the array indices in the listener array behind the listener.\n     */\n    async removeListener(eventType, listener, options) {\n        const emitter = await this.deregisterEventListener(eventType, options);\n        if (emitter) {\n            emitter.removeListener(eventType, listener);\n            this.deleteEmitterIfNothingRegistered(emitter);\n        }\n        return this;\n    }\n    async deregisterAllListeners(eventType) {\n        const runtimeEvent = { ...this.identity, type: eventType, topic: this.topic };\n        if (this.hasEmitter()) {\n            const emitter = this.getOrCreateEmitter();\n            const refCount = emitter.listenerCount(runtimeEvent.type);\n            const unsubscribePromises = [];\n            for (let i = 0; i < refCount; i++) {\n                unsubscribePromises.push(this.wire.sendAction('unsubscribe-to-desktop-event', runtimeEvent).catch(() => null));\n            }\n            await Promise.all(unsubscribePromises);\n            return emitter;\n        }\n        return undefined;\n    }\n    /**\n     * Removes all listeners, or those of the specified event.\n     *\n     */\n    async removeAllListeners(eventType) {\n        const removeByEvent = async (event) => {\n            const emitter = await this.deregisterAllListeners(event);\n            if (emitter) {\n                emitter.removeAllListeners(event);\n                this.deleteEmitterIfNothingRegistered(emitter);\n            }\n        };\n        if (eventType) {\n            await removeByEvent(eventType);\n        }\n        else if (this.hasEmitter()) {\n            const events = this.getOrCreateEmitter().eventNames();\n            await (0, promises_1.promiseMap)(events, removeByEvent);\n        }\n        return this;\n    }\n    deleteEmitterIfNothingRegistered(emitter) {\n        if (emitter.eventNames().length === 0) {\n            this.wire.eventAggregator.delete(__classPrivateFieldGet$e(this, _EmitterBase_emitterAccessor, \"f\"));\n        }\n    }\n}\nbase.EmitterBase = EmitterBase;\n_EmitterBase_emitterAccessor = new WeakMap();\nclass Reply {\n}\nbase.Reply = Reply;\n\nvar transportErrors = {};\n\nObject.defineProperty(transportErrors, \"__esModule\", { value: true });\ntransportErrors.RuntimeError = transportErrors.NotSupportedError = transportErrors.NotImplementedError = transportErrors.NoAckError = transportErrors.DuplicateCorrelationError = transportErrors.UnexpectedActionError = transportErrors.DisconnectedError = void 0;\nclass DisconnectedError extends Error {\n    constructor(readyState) {\n        super(`Expected websocket state OPEN but found ${readyState}`);\n        this.readyState = readyState;\n    }\n}\ntransportErrors.DisconnectedError = DisconnectedError;\nclass UnexpectedActionError extends Error {\n}\ntransportErrors.UnexpectedActionError = UnexpectedActionError;\nclass DuplicateCorrelationError extends Error {\n}\ntransportErrors.DuplicateCorrelationError = DuplicateCorrelationError;\nclass NoAckError extends Error {\n}\ntransportErrors.NoAckError = NoAckError;\nclass NotImplementedError extends Error {\n}\ntransportErrors.NotImplementedError = NotImplementedError;\nclass NotSupportedError extends Error {\n}\ntransportErrors.NotSupportedError = NotSupportedError;\nclass InternalError extends Error {\n    constructor(err) {\n        const { message, name, stack, ...rest } = err;\n        super(message);\n        this.name = name || 'Error';\n        this.stack = stack ?? this.toString();\n        Object.keys(rest).forEach(key => {\n            this[key] = rest[key];\n        });\n    }\n}\n// For documentation of the error methods being used see here: https://v8.dev/docs/stack-trace-api\nclass RuntimeError extends Error {\n    static getCallSite(callsToRemove = 0) {\n        const length = Error.stackTraceLimit;\n        const realCallsToRemove = callsToRemove + 1; // remove this call;\n        Error.stackTraceLimit = length + realCallsToRemove;\n        // eslint-disable-next-line no-underscore-dangle\n        const _prepareStackTrace = Error.prepareStackTrace;\n        // This will be called when we access the `stack` property\n        Error.prepareStackTrace = (_, stack) => stack;\n        // stack is optional in non chromium contexts\n        const stack = new Error().stack?.slice(realCallsToRemove) ?? [];\n        Error.prepareStackTrace = _prepareStackTrace;\n        Error.stackTraceLimit = length;\n        return stack;\n    }\n    static prepareStackTrace(err, callSites) {\n        if (typeof Error.prepareStackTrace === 'function') {\n            return Error.prepareStackTrace(err, callSites);\n        }\n        let string = \"\";\n        string += err.name || \"Error\";\n        string += `: ${err.message || \"\"}`;\n        for (const callSite of callSites) {\n            string += `\\n    at ${callSite.toString()}`;\n        }\n        return string;\n    }\n    ;\n    constructor(payload, callSites) {\n        const { reason, error } = payload;\n        super(reason);\n        this.name = 'RuntimeError';\n        if (error?.stack) {\n            this.cause = new InternalError(error);\n        }\n        if (callSites) {\n            this.stack = RuntimeError.prepareStackTrace(this, callSites);\n        }\n    }\n}\ntransportErrors.RuntimeError = RuntimeError;\n\nvar window$1 = {};\n\nvar Factory$8 = {};\n\nvar validate = {};\n\nObject.defineProperty(validate, \"__esModule\", { value: true });\nvalidate.validateIdentity = void 0;\nfunction validateIdentity(identity) {\n    let errorMsg;\n    if (typeof identity !== 'object' || typeof identity.uuid !== 'string') {\n        errorMsg = 'Not a valid identity object';\n    }\n    return errorMsg;\n}\nvalidate.validateIdentity = validateIdentity;\n\nvar Instance$7 = {};\n\nvar application = {};\n\nvar Factory$7 = {};\n\nvar Instance$6 = {};\n\nvar view = {};\n\nvar Factory$6 = {};\n\nvar warnings = {};\n\nObject.defineProperty(warnings, \"__esModule\", { value: true });\nwarnings.handleDeprecatedWarnings = void 0;\nconst handleDeprecatedWarnings = (options) => {\n    if (options.contentNavigation?.whitelist ||\n        options.contentNavigation?.blacklist ||\n        options.contentRedirect?.whitelist ||\n        options.contentRedirect?.blacklist) {\n        console.warn(`The properties 'whitelist' and 'blacklist' have been marked as deprecated and will be removed in a future version. Please use 'allowlist' and 'denylist'.`);\n    }\n};\nwarnings.handleDeprecatedWarnings = handleDeprecatedWarnings;\n\nvar hasRequiredFactory$3;\n\nfunction requireFactory$3 () {\n\tif (hasRequiredFactory$3) return Factory$6;\n\thasRequiredFactory$3 = 1;\n\tObject.defineProperty(Factory$6, \"__esModule\", { value: true });\n\tFactory$6.ViewModule = void 0;\n\tconst base_1 = base;\n\tconst validate_1 = validate;\n\tconst index_1 = requireView();\n\tconst warnings_1 = warnings;\n\t/**\n\t * Static namespace for OpenFin API methods that interact with the {@link View} class, available under `fin.View`.\n\t */\n\tclass ViewModule extends base_1.Base {\n\t    /**\n\t     * Creates a new View.\n\t     * @param options - View creation options\n\t     *\n\t     * @example\n\t     * ```js\n\t     * let view;\n\t     * async function createView() {\n\t     *     const me = await fin.Window.getCurrent();\n\t     *     return fin.View.create({\n\t     *         name: 'viewNameCreate',\n\t     *         target: me.identity,\n\t     *         bounds: {top: 10, left: 10, width: 200, height: 200}\n\t     *     });\n\t     * }\n\t     *\n\t     * createView()\n\t     *     .then((createdView) => {\n\t     *         view = createdView;\n\t     *         console.log('View created.', view);\n\t     *         view.navigate('https://google.com');\n\t     *         console.log('View navigated to given url.');\n\t     *     })\n\t     *     .catch(err => console.log(err));\n\t     * ```\n\t     * Note that created views needs to navigate somewhere for them to actually render a website.\n\t     * @experimental\n\t     */\n\t    async create(options) {\n\t        const { uuid } = this.wire.me;\n\t        if (!options.name || typeof options.name !== 'string') {\n\t            throw new Error('Please provide a name property as a string in order to create a View.');\n\t        }\n\t        (0, warnings_1.handleDeprecatedWarnings)(options);\n\t        if (this.wire.environment.childViews) {\n\t            await this.wire.environment.createChildContent({\n\t                entityType: 'view',\n\t                options: { ...options, uuid }\n\t            });\n\t        }\n\t        else {\n\t            await this.wire.sendAction('create-view', { ...options, uuid });\n\t        }\n\t        return this.wrapSync({ uuid, name: options.name });\n\t    }\n\t    /**\n\t     * Asynchronously returns an API handle for the given View identity.\n\t     *\n\t     * @remarks Wrapping a View identity that does not yet exist will *not* throw an error, and instead\n\t     * returns a stub object that cannot yet perform rendering tasks. This can be useful for plumbing eventing\n\t     * for a View throughout its entire lifecycle.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.View.wrap({ uuid: 'testViewUuid', name: 'testViewName' }))\n\t     *     .then(view => console.log('wrapped view', view))\n\t     *     .catch(err => console.log(err));\n\t     * ```\n\t     * @experimental\n\t     */\n\t    async wrap(identity) {\n\t        this.wire.sendAction('view-wrap').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const errorMsg = (0, validate_1.validateIdentity)(identity);\n\t        if (errorMsg) {\n\t            throw new Error(errorMsg);\n\t        }\n\t        return new index_1.View(this.wire, identity);\n\t    }\n\t    /**\n\t     * Synchronously returns an API handle for the given View identity.\n\t     *\n\t     * @remarks Wrapping a View identity that does not yet exist will *not* throw an error, and instead\n\t     * returns a stub object that cannot yet perform rendering tasks. This can be useful for plumbing eventing\n\t     * for a View throughout its entire lifecycle.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * const view = fin.View.wrapSync({ uuid: 'testView', name: 'testViewName' });\n\t     * await view.hide();\n\t     * ```\n\t     * @experimental\n\t     */\n\t    wrapSync(identity) {\n\t        this.wire.sendAction('view-wrap-sync').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const errorMsg = (0, validate_1.validateIdentity)(identity);\n\t        if (errorMsg) {\n\t            throw new Error(errorMsg);\n\t        }\n\t        return new index_1.View(this.wire, identity);\n\t    }\n\t    /**\n\t     * Asynchronously returns a View object that represents the current view\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.View.getCurrent()\n\t     *     .then(view => console.log('current view', view))\n\t     *     .catch(err => console.log(err));\n\t     *\n\t     * ```\n\t     * @experimental\n\t     */\n\t    getCurrent() {\n\t        this.wire.sendAction('view-get-current').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        if (!this.wire.me.isView) {\n\t            throw new Error('You are not in a View context');\n\t        }\n\t        const { uuid, name } = this.wire.me;\n\t        return this.wrap({ uuid, name });\n\t    }\n\t    /**\n\t     * Synchronously returns a View object that represents the current view\n\t     *\n\t     * @example\n\t     * ```js\n\t     * const view = fin.View.getCurrentSync();\n\t     * console.log(view);\n\t     *\n\t     * ```\n\t     * @experimental\n\t     */\n\t    getCurrentSync() {\n\t        this.wire.sendAction('view-get-current-sync').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        if (!this.wire.me.isView) {\n\t            throw new Error('You are not in a View context');\n\t        }\n\t        const { uuid, name } = this.wire.me;\n\t        return this.wrapSync({ uuid, name });\n\t    }\n\t}\n\tFactory$6.ViewModule = ViewModule;\n\treturn Factory$6;\n}\n\nvar Instance$5 = {};\n\nvar lazy = {};\n\nObject.defineProperty(lazy, \"__esModule\", { value: true });\nlazy.AsyncRetryableLazy = lazy.Lazy = void 0;\n/**\n * Handy class for managing asynchronous dependencies of classes.\n *\n * Will call the producer function once and only once when getValue is called,\n * returning the resultant value for every subsequent call.\n */\nclass Lazy {\n    // eslint-disable-next-line\n    constructor(producerFn) {\n        this.producerFn = producerFn;\n    }\n    /**\n     * Lazily get the value returned by the producer.\n     * @returns The value returned from the producer function\n     */\n    getValue() {\n        if (!this.value) {\n            this.value = this.producerFn();\n        }\n        return this.value;\n    }\n}\nlazy.Lazy = Lazy;\n/**\n * Handy class for managing asynchronous dependencies of classes.\n *\n * Will call asynchronous producer only after `getValue` is called.  If the\n * deferred code errors, we can try it again by re-calling `getValue` after\n * the promise rejects.\n */\nclass AsyncRetryableLazy {\n    // eslint-disable-next-line\n    constructor(producerFn) {\n        this.producerFn = producerFn;\n    }\n    /**\n     * Lazily get the value returned by the async producer.\n     *\n     * @returns The value returned from the producer function\n     */\n    async getValue() {\n        if (!this.promise) {\n            this.promise = this.producerFn().catch((e) => {\n                delete this.promise;\n                throw e;\n            });\n        }\n        return this.promise;\n    }\n}\nlazy.AsyncRetryableLazy = AsyncRetryableLazy;\n\nvar layoutEntities = {};\n\nvar apiExposer$1 = {};\n\nvar apiConsumer = {};\n\nObject.defineProperty(apiConsumer, \"__esModule\", { value: true });\napiConsumer.ApiConsumer = void 0;\n/**\n * Consumer for apis exposed with {@see ApiExposer}.\n *\n * A strategy that matches the strategy used to expose a target API must be provided.\n */\nclass ApiConsumer {\n    // eslint-disable-next-line\n    constructor(strategy) {\n        this.strategy = strategy;\n        /**\n         * Consumes an api exposed using a given transport strategy, and generates a client\n         * for easy, type safe consumption of that client.\n         * @param options Strategy specific consumption options.\n         * @returns An api client matching the given type.\n         */\n        this.consume = async (options) => {\n            const exposedProperties = await this.strategy.getExposedFunctions(options);\n            return exposedProperties.reduce((client, prop) => ({\n                ...client,\n                [prop.key]: this.strategy.createFunction(prop, options)\n            }), {});\n        };\n    }\n}\napiConsumer.ApiConsumer = ApiConsumer;\n\nvar apiExposer = {};\n\nvar decorators = {};\n\nObject.defineProperty(decorators, \"__esModule\", { value: true });\ndecorators.expose = decorators.getExposedProperties = void 0;\nconst exposedProperties = Symbol('exposedProperties');\nconst getExposedProperties = (target) => {\n    return target[exposedProperties] || target.prototype[exposedProperties] || [];\n};\ndecorators.getExposedProperties = getExposedProperties;\n/**\n * Indicates that a class member function can be exposed using {@link ApiExposer}.\n * @param options Options specific to the strategy used in {@link ApiExposer}\n */\n// Returns any as decorator typing is weird.\nconst expose = (options) => (target, key, descriptor) => {\n    target[exposedProperties] = target[exposedProperties] || [];\n    target[exposedProperties].push({ key, descriptor, options });\n};\ndecorators.expose = expose;\n\nObject.defineProperty(apiExposer, \"__esModule\", { value: true });\napiExposer.ApiExposer = void 0;\nconst decorators_1 = decorators;\n/**\n * Exposes api services on the transport of choice.\n */\nclass ApiExposer {\n    /**\n     * @param strategy The expose strategy to use to expose instances.\n     */\n    // eslint-disable-next-line\n    constructor(strategy) {\n        this.strategy = strategy;\n        /**\n         * Exposes an instance of a given api on\n         * @param instance Instance of a class which has been decorated to indicate which functions can be exposed.\n         * @param instanceOptions Transport strategy specific options to use when exposing.\n         */\n        this.exposeInstance = async (instance, instanceOptions) => {\n            const exposableProps = (0, decorators_1.getExposedProperties)(instance);\n            const exposedProps = await Promise.all(exposableProps.map(async ({ key, options }) => {\n                const customConsumptionOptions = await this.strategy.exposeFunction(instance[key].bind(instance), {\n                    key,\n                    options,\n                    meta: instanceOptions\n                });\n                return {\n                    key,\n                    options: customConsumptionOptions\n                };\n            }));\n            await this.strategy.exposeMeta(instanceOptions, exposedProps);\n        };\n    }\n    ;\n}\napiExposer.ApiExposer = ApiExposer;\n\nvar strategies = {};\n\nvar openfinChannels = {};\n\nvar channelsConsumer = {};\n\nObject.defineProperty(channelsConsumer, \"__esModule\", { value: true });\nchannelsConsumer.ChannelsConsumer = void 0;\nclass ChannelsConsumer {\n    // eslint-disable-next-line\n    constructor(channel) {\n        this.channel = channel;\n        this.getExposedFunctions = async (options) => {\n            const { id } = options;\n            const { props } = await this.channel.dispatch(`api-meta:${id}`);\n            return props;\n        };\n        this.createFunction = (prop) => (...args) => {\n            const { action } = prop.options;\n            return this.channel.dispatch(action, { args });\n        };\n    }\n    ;\n}\nchannelsConsumer.ChannelsConsumer = ChannelsConsumer;\n\nvar channelsExposer = {};\n\nObject.defineProperty(channelsExposer, \"__esModule\", { value: true });\nchannelsExposer.ChannelsExposer = void 0;\nclass ChannelsExposer {\n    // eslint-disable-next-line\n    constructor(channelProviderOrClient) {\n        this.channelProviderOrClient = channelProviderOrClient;\n        this.exposeFunction = async (target, config) => {\n            const { key, options, meta } = config;\n            const { id } = meta;\n            const action = `${id}.${options?.action || key}`;\n            await this.channelProviderOrClient.register(action, async ({ args }) => {\n                return target(...args);\n            });\n            return { action };\n        };\n        this.exposeMeta = async ({ id }, props) => {\n            const action = `api-meta:${id}`;\n            await this.channelProviderOrClient.register(action, () => ({ props }));\n        };\n    }\n}\nchannelsExposer.ChannelsExposer = ChannelsExposer;\n\n(function (exports) {\n\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t    }\n\t    Object.defineProperty(o, k2, desc);\n\t}) : (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    o[k2] = m[k];\n\t}));\n\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t};\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t__exportStar(channelsConsumer, exports);\n\t__exportStar(channelsExposer, exports); \n} (openfinChannels));\n\n(function (exports) {\n\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t    }\n\t    Object.defineProperty(o, k2, desc);\n\t}) : (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    o[k2] = m[k];\n\t}));\n\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t};\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t__exportStar(openfinChannels, exports); \n} (strategies));\n\n(function (exports) {\n\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t    }\n\t    Object.defineProperty(o, k2, desc);\n\t}) : (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    o[k2] = m[k];\n\t}));\n\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t};\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t__exportStar(apiConsumer, exports);\n\t__exportStar(apiExposer, exports);\n\t__exportStar(strategies, exports);\n\t__exportStar(decorators, exports); \n} (apiExposer$1));\n\nvar channelApiRelay = {};\n\nObject.defineProperty(channelApiRelay, \"__esModule\", { value: true });\nchannelApiRelay.createRelayedDispatch = channelApiRelay.relayChannelClientApi = void 0;\nconst EXPECTED_ERRORS = [\n    'no longer connected',\n    'RTCDataChannel closed unexpectedly',\n    'The client you are trying to dispatch from is disconnected from the target provider',\n];\n// Checks possible error messages that we want to trap, client error message can originate\n// from ChannelProvider::dispatch OR ClassicStrategy::closeEndpoint OR RTCEndPoint::dataChannel::onclose\nconst isDisconnectedError = (errorMsg) => {\n    return EXPECTED_ERRORS.some(e => errorMsg.includes(e));\n};\n/**\n * @internal\n * Create a channel relay for a given channel exposition, allowing a single provider to route\n * actions to the designated clients.\n *\n * Designed to be used in conjunction with @expose\n *\n * @param channelProvider The channel provider to relay the actions on.\n * @param config Determines which actions to relay. Please ensure action prefix matches the exposed api.\n */\nconst relayChannelClientApi = async (channelProvider, relayId) => {\n    channelProvider.register(`relay:${relayId}`, ({ action, target, payload }) => {\n        return channelProvider.dispatch(target, action, payload);\n    });\n    await Promise.resolve();\n};\nchannelApiRelay.relayChannelClientApi = relayChannelClientApi;\nconst createRelayedDispatch = (client, target, relayId, relayErrorMsg) => async (action, payload) => {\n    try {\n        return await client.dispatch(`relay:${relayId}`, {\n            action,\n            payload,\n            target\n        });\n    }\n    catch (e) {\n        if (isDisconnectedError(e.message) && relayErrorMsg) {\n            throw new Error(relayErrorMsg);\n        }\n        throw e;\n    }\n};\nchannelApiRelay.createRelayedDispatch = createRelayedDispatch;\n\nvar __classPrivateFieldSet$b = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar __classPrivateFieldGet$d = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar _LayoutNode_client, _TabStack_client, _ColumnOrRow_client;\nObject.defineProperty(layoutEntities, \"__esModule\", { value: true });\nlayoutEntities.ColumnOrRow = layoutEntities.TabStack = layoutEntities.LayoutNode = void 0;\nconst api_exposer_1 = apiExposer$1;\nconst channel_api_relay_1 = channelApiRelay;\n/*\n    This file includes LayoutNode, ColumnOrRow and TabStack classes, which are all closely\n    intertwined, and share members via parent abstract class LayoutNode. To prevent circular\n    refs, we define and export all the classes here.\n*/\n/**\n * @ignore\n * @internal\n * Supplies an ApiClient for {@link LayoutEntitiesController} and helper methods\n * for the entities {@link TabStack} AND {@link ColumnOrRow} to use.\n */\nclass LayoutNode {\n    /**\n     * @internal\n     * @ignore\n     */\n    constructor(client, entityId) {\n        /**\n         * @ignore\n         * @internal\n         * ApiClient for {@link LayoutEntitiesController}\n         */\n        _LayoutNode_client.set(this, void 0);\n        /**\n         * Checks if the TabStack or ColumnOrRow is the root content item\n         *\n         * @example\n         * ```js\n         * if (!fin.me.isView) {\n         *     throw new Error('Not running in a platform View.');\n         * }\n         *\n         * const stack = await fin.me.getCurrentStack();\n         * const isRoot = await stack.isRoot();\n         * // The TabStack is root: false\n         * console.log(`The TabStack is root: ${isRoot}`);\n         *\n         * // Retrieves the parent ColumnOrRow\n         * const parent = await stack.getParent();\n         * const parentIsRoot = await parent.isRoot();\n         * // The parent ColumnOrRow is root: true\n         * console.log(`The parent ColumnOrRow is root: ${parentIsRoot}`);\n         * ```\n         */\n        this.isRoot = () => __classPrivateFieldGet$d(this, _LayoutNode_client, \"f\").isRoot(this.entityId);\n        /**\n         * Checks if the TabStack or ColumnOrRow exists\n         *\n         * @example\n         * ```js\n         * if (!fin.me.isView) {\n         *     throw new Error('Not running in a platform View.');\n         * }\n         *\n         * const stack = await fin.me.getCurrentStack();\n         * // Retrieves the parent ColumnOrRow\n         * const columnOrRow = await stack.getParent();\n         * let exists = await stack.exists();\n         * // or\n         * let exists = await columnOrRow.exists();\n         * // The entity exists: true\n         * console.log(`The entity exists: ${exists}`);\n         * ```\n         */\n        this.exists = () => __classPrivateFieldGet$d(this, _LayoutNode_client, \"f\").exists(this.entityId);\n        /**\n         * Retrieves the parent of the TabStack or ColumnOrRow\n         *\n         * @example\n         * ```js\n         * if (!fin.me.isView) {\n         *     throw new Error('Not running in a platform View.');\n         * }\n         *\n         * const stack = await fin.me.getCurrentStack();\n         * // Retrieves the parent ColumnOrRow\n         * const columnOrRow = await stack.getParent();\n         *\n         * // undefined if entity is the root item\n         * let parent = await columnOrRow.getParent();\n         * // or\n         * let parent = await stack.getParent();\n         * ```\n         */\n        this.getParent = async () => {\n            const parent = await __classPrivateFieldGet$d(this, _LayoutNode_client, \"f\").getParent(this.entityId);\n            if (!parent) {\n                return undefined;\n            }\n            return LayoutNode.getEntity(parent, __classPrivateFieldGet$d(this, _LayoutNode_client, \"f\"));\n        };\n        /**\n         * Creates a new TabStack adjacent to the given TabStack or ColumnOrRow. Inputs can be new views to create, or existing views.\n         *\n         * Known Issue: If the number of views to add overflows the tab-container, the added views will be set as active\n         * during each render, and then placed at the front of the tab-stack, while the underlying order of tabs will remain unchanged.\n         * This means the views you pass to createAdjacentStack() may not render in the order given by the array.\n         * Until fixed, this problem can be avoided only if your window is wide enough to fit creating all the views in the tabstack.\n         *\n         * @param views The views that will populate the new TabStack.\n         * @param options Additional options that control new TabStack creation.\n         * @returns The newly-created TabStack.\n         *\n         * @example\n         * ```js\n         * if (!fin.me.isView) {\n         *     throw new Error('Not running in a platform View.');\n         * }\n         *\n         * const stack = await fin.me.getCurrentStack();\n         * const columnOrRow = await stack.getParent();\n         *\n         * // Create view references by supplying a 'name' and 'url'\n         * const views = [\n         *     // if 'name' is undefined, one will be generated\n         *     // if 'url' is undefined, it will default the view URL to 'about:blank'\n         *     { name: 'google-view', url: 'http://google.com/'},\n         *     { name: 'of-developers-view', url: 'http://developers.openfin.co/'},\n         * ];\n         *\n         * // Create a view beforehand to be included in the new tab stack\n         * const outsideView = await fin.View.create({\n         *     name: 'outside-bloomberg-view',\n         *     url: 'https://bloomberg.com/',\n         *     target: fin.me.identity,\n         * });\n         *\n         * // Views to add can be identities, or the reference views mentioned above\n         * const viewsToAdd = [outsideView.identity, ...views];\n         *\n         * // Possible position inputs: 'right' | 'left' | 'top' | 'bottom'\n         * let stackFrom = await columnOrRow.createAdjacentStack(viewsToAdd, { position: 'right' });\n         * // Or\n         * let newStack = await stack.createAdjacentStack(viewsToAdd, { position: 'right' });\n         * console.log(`A new TabStack created to the right has ${newStack.length} views in it`);\n         *\n         * ```\n         * @experimental\n         */\n        this.createAdjacentStack = async (views, options) => {\n            const entityId = await __classPrivateFieldGet$d(this, _LayoutNode_client, \"f\").createAdjacentStack(this.entityId, views, options);\n            return LayoutNode.getEntity({ entityId, type: 'stack' }, __classPrivateFieldGet$d(this, _LayoutNode_client, \"f\"));\n        };\n        /**\n         * Retrieves the adjacent TabStacks of the given TabStack or ColumnOrRow.\n         *\n         * @param edge Edge whose adjacent TabStacks will be returned.\n         *\n         * @example\n         * ```js\n         * if (!fin.me.isView) {\n         *     throw new Error('Not running in a platform View.');\n         * }\n         *\n         * const stack = await fin.me.getCurrentStack();\n         * const columnOrRow = await stack.getParent();\n         * // Possible position inputs: 'right' | 'left' | 'top' | 'bottom'\n         * let rightStacks = await columnOrRow.getAdjacentStacks('right');\n         * let leftStacks = await columnOrRow.getAdjacentStacks('left');\n         * // or\n         * let rightStacks = await stack.getAdjacentStacks('right');\n         * let leftStacks = await stack.getAdjacentStacks('left');\n         *\n         * console.log(`The entity has ${rightStacks.length} stacks to the right, and ${leftStacks.length} stacks to the left`);\n         *\n         * ```\n         * @experimental\n         */\n        this.getAdjacentStacks = async (edge) => {\n            const adjacentStacks = await __classPrivateFieldGet$d(this, _LayoutNode_client, \"f\").getAdjacentStacks({\n                targetId: this.entityId,\n                edge\n            });\n            return adjacentStacks.map((stack) => LayoutNode.getEntity({\n                type: 'stack',\n                entityId: stack.entityId\n            }, __classPrivateFieldGet$d(this, _LayoutNode_client, \"f\")));\n        };\n        __classPrivateFieldSet$b(this, _LayoutNode_client, client, \"f\");\n        this.entityId = entityId;\n    }\n}\nlayoutEntities.LayoutNode = LayoutNode;\n_LayoutNode_client = new WeakMap();\n/**\n * @ignore\n * @internal\n * Encapsulates Api consumption of {@link LayoutEntitiesClient} with a relayed dispatch\n * @param client\n * @param controllerId\n * @param identity\n * @returns a new instance of {@link LayoutEntitiesClient} with bound to the controllerId\n */\nLayoutNode.newLayoutEntitiesClient = async (client, controllerId, identity) => {\n    const dispatch = (0, channel_api_relay_1.createRelayedDispatch)(client, identity, 'layout-relay', 'You are trying to interact with a layout component on a window that does not exist or has been destroyed.');\n    const consumer = new api_exposer_1.ApiConsumer(new api_exposer_1.ChannelsConsumer({ dispatch }));\n    return consumer.consume({ id: controllerId });\n};\nLayoutNode.getEntity = (definition, client) => {\n    const { entityId, type } = definition;\n    switch (type) {\n        case 'column':\n        case 'row':\n            return new ColumnOrRow(client, entityId, type);\n        case 'stack':\n            return new TabStack(client, entityId);\n        default:\n            throw new Error(`Unrecognised Layout Entity encountered ('${JSON.stringify(definition)})`);\n    }\n};\n/**\n * A TabStack is used to manage the state of a stack of tabs within an OpenFin Layout.\n */\nclass TabStack extends LayoutNode {\n    /** @internal */\n    constructor(client, entityId) {\n        super(client, entityId);\n        /**\n         * @internal\n         * ApiClient for {@link LayoutEntitiesController}\n         */\n        _TabStack_client.set(this, void 0);\n        /**\n         * Type of the content item. Always stack, but useful for distinguishing between a {@link TabStack} and {@link ColumnOrRow}.\n         */\n        this.type = 'stack';\n        /**\n         * Retrieves a list of all views belonging to this {@link TabStack}.\n         *\n         * Known Issue: If adding a view overflows the tab-container width, the added view will be set as active\n         * and rendered at the front of the tab-stack, while the underlying order of tabs will remain unchanged.\n         * If that happens and then getViews() is called, it will return the identities in a different order than\n         * than the currently rendered tab order.\n         *\n         *\n         * @throws If the {@link TabStack} has been destroyed.\n         * @example\n         * ```js\n         * if (!fin.me.isView) {\n         *     throw new Error('Not running in a platform View.');\n         * }\n         *\n         * const stack = await fin.me.getCurrentStack();\n         * // Alternatively, you can wrap any view and get the stack from there\n         * // const viewFromSomewhere = fin.View.wrapSync(someView.identity);\n         * // const stack = await viewFromSomewhere.getCurrentStack();\n         * const views = await stack.getViews();\n         * console.log(`Stack contains ${views.length} view(s)`);\n         * ```\n         * @experimental\n         */\n        this.getViews = () => __classPrivateFieldGet$d(this, _TabStack_client, \"f\").getStackViews(this.entityId);\n        /**\n         * Adds or creates a view in this {@link TabStack}.\n         *\n         * @remarks Known Issue: If adding a view overflows the tab-container, the added view will be set as active\n         * and rendered at the front of the tab-stack, while the underlying order of tabs will remain unchanged.\n         *\n         * @param view The identity of an existing view to add, or options to create a view.\n         * @param options Optional view options: index number used to insert the view into the stack at that index. Defaults to 0 (front of the stack)\n         * @returns Resolves with the {@link OpenFin.Identity identity} of the added view.\n         * @throws If the view does not exist or fails to create.\n         * @throws If the {@link TabStack} has been destroyed.\n         * @example\n         * ```js\n         * if (!fin.me.isView) {\n         *     throw new Error('Not running in a platform View.');\n         * }\n         *\n         * const stack = await fin.me.getCurrentStack();\n         * // Alternatively, you can wrap any view and get the stack from there\n         * // const viewFromSomewhere = fin.View.wrapSync(someView.identity);\n         * // const stack = await viewFromSomewhere.getCurrentStack();\n         * const googleViewIdentity = await stack.addView({ name: 'google-view', url: 'http://google.com/' });\n         * console.log('Identity of the google view just added', { googleViewIdentity });\n         * // pass in { index: number } to set the index in the stack. Here 1 means, end of the stack (defaults to 0)\n         * const appleViewIdentity = await stack.addView({ name: 'apple-view', url: 'http://apple.com/' }, { index: 1 });\n         * console.log('Identity of the apple view just added', { appleViewIdentity });\n         * ```\n         * @experimental\n         */\n        this.addView = async (view, options = { index: 0 }) => __classPrivateFieldGet$d(this, _TabStack_client, \"f\").addViewToStack(this.entityId, view, options);\n        /**\n         * Removes a view from this {@link TabStack}.\n         *\n         * @remarks Throws an exception if the view identity does not exist or was already destroyed.\n         *\n         * @param view - Identity of the view to remove.\n         * @throws If the view does not exist or does not belong to the stack.\n         * @throws If the {@link TabStack} has been destroyed.\n         *\n         * @example\n         * ```js\n         * if (!fin.me.isView) {\n         *     throw new Error('Not running in a platform View.');\n         * }\n         *\n         * const stack = await fin.me.getCurrentStack();\n         * const googleViewIdentity = await stack.addView({ name: 'google-view', url: 'http://google.com/' });\n         *\n         * await stack.removeView(googleViewIdentity);\n         *\n         * try {\n         *     await stack.removeView(googleViewIdentity);\n         * } catch (error) {\n         *     // Tried to remove a view ('google-view') which does not belong to the stack.\n         *     console.log(error);\n         * }\n         * ```\n         */\n        this.removeView = async (view) => {\n            await __classPrivateFieldGet$d(this, _TabStack_client, \"f\").removeViewFromStack(this.entityId, view);\n        };\n        /**\n         * Sets the active view of the {@link TabStack} without focusing it.\n         * @param view - Identity of the view to activate.\n         * @returns Promise which resolves with void once the view has been activated.\n         * @throws If the {@link TabStack} has been destroyed.\n         * @throws If the view does not exist.\n         * @example\n         * Change the active tab of a known View's TabStack:\n         * ```js\n         * const targetView = fin.View.wrapSync({ uuid: 'uuid', name: 'view-name' });\n         * const stack = await targetView.getCurrentStack();\n         * await stack.setActiveView(targetView.identity);\n         * ```\n         *\n         * Set the current View as active within its TabStack:\n         * ```js\n         * const stack = await fin.me.getCurrentStack();\n         * await stack.setActiveView(fin.me.identity);\n         * ```\n         * @experimental\n         */\n        this.setActiveView = async (view) => {\n            await __classPrivateFieldGet$d(this, _TabStack_client, \"f\").setStackActiveView(this.entityId, view);\n        };\n        __classPrivateFieldSet$b(this, _TabStack_client, client, \"f\");\n    }\n}\nlayoutEntities.TabStack = TabStack;\n_TabStack_client = new WeakMap();\n/**\n * A ColumnOrRow is used to manage the state of Column and Rows within an OpenFin Layout.\n */\nclass ColumnOrRow extends LayoutNode {\n    /**\n     * @internal\n     */\n    constructor(client, entityId, type) {\n        super(client, entityId);\n        /**\n         * @ignore\n         * @internal\n         * ApiClient for {@link LayoutEntitiesController}\n         */\n        _ColumnOrRow_client.set(this, void 0);\n        /**\n         * Retrieves the content array of the ColumnOrRow\n         *\n         * @example\n         * ```js\n         * if (!fin.me.isView) {\n         *     throw new Error('Not running in a platform View.');\n         * }\n         *\n         * const stack = await fin.me.getCurrentStack();\n         * // Retrieves the parent ColumnOrRow\n         * const columnOrRow = await stack.getParent();\n         *\n         * // returns [TabStack]\n         * const contentArray = await columnOrRow.getContent();\n         * console.log(`The ColumnOrRow has ${contentArray.length} item(s)`);\n         * ```\n         */\n        this.getContent = async () => {\n            const contentItemEntities = await __classPrivateFieldGet$d(this, _ColumnOrRow_client, \"f\").getContent(this.entityId);\n            return contentItemEntities.map((entity) => LayoutNode.getEntity(entity, __classPrivateFieldGet$d(this, _ColumnOrRow_client, \"f\")));\n        };\n        __classPrivateFieldSet$b(this, _ColumnOrRow_client, client, \"f\");\n        this.type = type;\n    }\n}\nlayoutEntities.ColumnOrRow = ColumnOrRow;\n_ColumnOrRow_client = new WeakMap();\n\nvar layout_constants = {};\n\nObject.defineProperty(layout_constants, \"__esModule\", { value: true });\nlayout_constants.DEFAULT_LAYOUT_KEY = layout_constants.LAYOUT_CONTROLLER_ID = void 0;\nlayout_constants.LAYOUT_CONTROLLER_ID = 'layout-entities';\n// TODO: eventually export this somehow\nlayout_constants.DEFAULT_LAYOUT_KEY = '__default__';\n\nvar main = {};\n\nObject.defineProperty(main, \"__esModule\", { value: true });\nmain.WebContents = void 0;\nconst base_1$j = base;\nclass WebContents extends base_1$j.EmitterBase {\n    /**\n     * @param identity The identity of the {@link OpenFin.WebContentsEvents WebContents}.\n     * @param entityType The type of the {@link OpenFin.WebContentsEvents WebContents}.\n     */\n    constructor(wire, identity, entityType) {\n        super(wire, entityType, identity.uuid, identity.name);\n        this.identity = identity;\n        this.entityType = entityType;\n    }\n    /**\n     * Gets a base64 encoded image of all or part of the WebContents.\n     * @param options Options for the capturePage call.\n     *\n     * @example\n     *\n     * View:\n     * ```js\n     * const view = fin.View.getCurrentSync();\n     *\n     * // PNG image of a full visible View\n     * console.log(await view.capturePage());\n     *\n     * // Low-quality JPEG image of a defined visible area of the view\n     * const options = {\n     *     area: {\n     *         height: 100,\n     *         width: 100,\n     *         x: 10,\n     *         y: 10,\n     *     },\n     *     format: 'jpg',\n     *     quality: 20\n     * }\n     * console.log(await view.capturePage(options));\n     * ```\n     *\n     * Window:\n     * ```js\n     * const wnd = await fin.Window.getCurrent();\n     *\n     * // PNG image of a full visible window\n     * console.log(await wnd.capturePage());\n     *\n     * // Low-quality JPEG image of a defined visible area of the window\n     * const options = {\n     *     area: {\n     *         height: 100,\n     *         width: 100,\n     *         x: 10,\n     *         y: 10,\n     *     },\n     *     format: 'jpg',\n     *     quality: 20\n     * }\n     * console.log(await wnd.capturePage(options));\n     * ```\n     *\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    capturePage(options) {\n        return this.wire.sendAction('capture-page', { options, ...this.identity }).then(({ payload }) => payload.data);\n    }\n    /**\n     * Executes Javascript on the WebContents, restricted to contents you own or contents owned by\n     * applications you have created.\n     * @param code JavaScript code to be executed on the view.\n     *\n     * @example\n     * View:\n     * ```js\n     * async function executeJavaScript(code) {\n     *     const view = await fin.View.wrap({uuid: 'uuid', name: 'view name'});\n     *     return await view.executeJavaScript(code);\n     * }\n     *\n     * executeJavaScript(`console.log('Hello, Openfin')`).then(() => console.log('Javascript excuted')).catch(err => console.log(err));\n     * ```\n     *\n     * Window:\n     * ```js\n     * async function executeJavaScript(code) {\n     *     const app = await fin.Application.start({\n     *         name: 'myApp',\n     *         uuid: 'app-1',\n     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.executeJavaScript.html',\n     *         autoShow: true\n     *     });\n     *     const win = await app.getWindow();\n     *     return await win.executeJavaScript(code);\n     * }\n     *\n     * executeJavaScript(`console.log('Hello, Openfin')`).then(() => console.log('Javascript excuted')).catch(err => console.log(err));\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    executeJavaScript(code) {\n        return this.wire\n            .sendAction('execute-javascript-in-window', { ...this.identity, code })\n            .then(({ payload }) => payload.data);\n    }\n    /**\n     * Returns the zoom level of the WebContents.\n     *\n     * @example\n     * View:\n     * ```js\n     * async function getZoomLevel() {\n     *     const view = await fin.View.getCurrent();\n     *     return await view.getZoomLevel();\n     * }\n     *\n     * getZoomLevel().then(zoomLevel => console.log(zoomLevel)).catch(err => console.log(err));\n     * ```\n     *\n     * Window:\n     * ```js\n     * async function createWin() {\n     *     const app = await fin.Application.start({\n     *         name: 'myApp',\n     *         uuid: 'app-1',\n     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getZoomLevel.html',\n     *         autoShow: true\n     *     });\n     *     return await app.getWindow();\n     * }\n     *\n     * async function getZoomLevel() {\n     *     const win = await createWin();\n     *     return await win.getZoomLevel();\n     * }\n     *\n     * getZoomLevel().then(zoomLevel => console.log(zoomLevel)).catch(err => console.log(err));\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    getZoomLevel() {\n        return this.wire.sendAction('get-zoom-level', this.identity).then(({ payload }) => payload.data);\n    }\n    /**\n     * Sets the zoom level of the WebContents.\n     * @param level The zoom level\n     *\n     * @example\n     * View:\n     * ```js\n     * async function setZoomLevel(number) {\n     *     const view = await fin.View.getCurrent();\n     *     return await view.setZoomLevel(number);\n     * }\n     *\n     * setZoomLevel(4).then(() => console.log('Setting a  zoom level')).catch(err => console.log(err));\n     * ```\n     *\n     * Window:\n     * ```js\n     * async function createWin() {\n     *     const app = await fin.Application.start({\n     *         name: 'myApp',\n     *         uuid: 'app-1',\n     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.setZoomLevel.html',\n     *         autoShow: true\n     *     });\n     *     return await app.getWindow();\n     * }\n     *\n     * async function setZoomLevel(number) {\n     *     const win = await createWin();\n     *     return await win.setZoomLevel(number);\n     * }\n     *\n     * setZoomLevel(4).then(() => console.log('Setting a  zoom level')).catch(err => console.log(err));\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    setZoomLevel(level) {\n        return this.wire.sendAction('set-zoom-level', { ...this.identity, level }).then(() => undefined);\n    }\n    /**\n     * Navigates the WebContents to a specified URL.\n     *\n     * Note: The url must contain the protocol prefix such as http:// or https://.\n     * @param url - The URL to navigate the WebContents to.\n     *\n     * @example\n     * View:\n     * ```js\n     * async function createView() {\n     *     const me = await fin.Window.getCurrent();\n     *     return fin.View.create({\n     *         name: 'viewName',\n     *         target: me.identity,\n     *         bounds: {top: 10, left: 10, width: 200, height: 200}\n     *     });\n     * }\n     *\n     * createView()\n     *     .then(view => view.navigate('https://example.com'))\n     *     .then(() => console.log('navigation complete'))\n     *     .catch(err => console.log(err));\n     * ```\n     *\n     * Window:\n     * ```js\n     * async function navigate() {\n     *     const win = await fin.Window.getCurrent();\n     *     return await win.navigate('https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.navigate.html');\n     * }\n     * navigate().then(() => console.log('Navigate to tutorial')).catch(err => console.log(err));\n     * ```\n     * @experimental\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    navigate(url) {\n        return this.wire.sendAction('navigate-window', { ...this.identity, url }).then(() => undefined);\n    }\n    /**\n     * Navigates the WebContents back one page.\n     *\n     * @example\n     * View:\n     * ```js\n     * async function navigateBack() {\n     *     const view = await fin.View.wrap({ name: 'testapp-view', uuid: 'testapp' });\n     *     await view.navigate('https://www.google.com');\n     *     return await view.navigateBack();\n     * }\n     * navigateBack().then(() => console.log('Navigated back')).catch(err => console.log(err));\n     * ```\n     *\n     * Window:\n     * ```js\n     * async function navigateBack() {\n     *     const win = await fin.Window.wrap({ name: 'testapp', uuid: 'testapp' });\n     *     await win.navigate('https://www.google.com');\n     *     return await win.navigateBack();\n     * }\n     * navigateBack().then(() => console.log('Navigated back')).catch(err => console.log(err));\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    navigateBack() {\n        return this.wire.sendAction('navigate-window-back', { ...this.identity }).then(() => undefined);\n    }\n    /**\n     * Navigates the WebContents forward one page.\n     *\n     * @example\n     * View:\n     * ```js\n     * async function navigateForward() {\n     *     const view = await fin.View.getCurrent();\n     *     await view.navigate('https://www.google.com');\n     *     await view.navigateBack();\n     *     return await view.navigateForward();\n     * }\n     * navigateForward().then(() => console.log('Navigated forward')).catch(err => console.log(err));\n     * ```\n     *\n     * Window:\n     * ```js\n     * async function navigateForward() {\n     *     const win = await fin.Window.getCurrent();\n     *     await win.navigate('https://www.google.com');\n     *     await win.navigateBack();\n     *     return await win.navigateForward();\n     * }\n     * navigateForward().then(() => console.log('Navigated forward')).catch(err => console.log(err));\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    async navigateForward() {\n        await this.wire.sendAction('navigate-window-forward', { ...this.identity });\n    }\n    /**\n     * Stops any current navigation the WebContents is performing.\n     *\n     * @example\n     * View:\n     * ```js\n     * async function stopNavigation() {\n     *     const view = await fin.View.wrap({ name: 'testapp-view', uuid: 'testapp' });\n     *     await view.navigate('https://www.google.com');\n     *     return await view.stopNavigation();\n     * }\n     * stopNavigation().then(() => console.log('you shall not navigate')).catch(err => console.log(err));\n     * ```\n     *\n     * Window:\n     * ```js\n     * async function stopNavigation() {\n     *     const win = await fin.Window.wrap({ name: 'testapp', uuid: 'testapp' });\n     *     await win.navigate('https://www.google.com');\n     *     return await win.stopNavigation();\n     * }\n     * stopNavigation().then(() => console.log('you shall not navigate')).catch(err => console.log(err));\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    stopNavigation() {\n        return this.wire.sendAction('stop-window-navigation', { ...this.identity }).then(() => undefined);\n    }\n    /**\n     * Reloads the WebContents\n     *\n     * @example\n     * View:\n     * ```js\n     * async function reload() {\n     * \tconst view = await fin.View.getCurrent();\n     *     return await view.reload();\n     * }\n     *\n     * reload().then(() => {\n     * \t\tconsole.log('Reloaded view')\n     * }).catch(err => console.log(err));\n     * ```\n     *\n     * Window:\n     * ```js\n     * async function reloadWindow() {\n     * \t\tconst app = await fin.Application.start({\n     * \t\t\t\tname: 'myApp',\n     * \t\t\t\tuuid: 'app-1',\n     * \t\t\t\turl: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.reload.html',\n     * \t\t\t\tautoShow: true\n     * \t\t});\n     * \t\tconst win = await app.getWindow();\n     *     return await win.reload();\n     * }\n     *\n     * reloadWindow().then(() => {\n     * \t\tconsole.log('Reloaded window')\n     * }).catch(err => console.log(err));\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    reload(ignoreCache = false) {\n        return this.wire\n            .sendAction('reload-window', {\n            ignoreCache,\n            ...this.identity\n        })\n            .then(() => undefined);\n    }\n    /**\n     * Prints the WebContents.\n     * @param options Printer Options\n     *\n     * Note: When `silent` is set to `true`, the API will pick the system's default printer if deviceName\n     * is empty and the default settings for printing.\n     *\n     * Use the CSS style `page-break-before: always;` to force print to a new page.\n     *\n     * @example\n     * ```js\n     * const view = fin.View.getCurrentSync();\n     *\n     * view.print({ silent: false, deviceName: 'system-printer-name' }).then(() => {\n     *     console.log('print call has been sent to the system');\n     * });\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    print(options = {}) {\n        return this.wire.sendAction('print', { ...this.identity, options }).then(() => undefined);\n    }\n    /**\n     * Find and highlight text on a page.\n     * @param searchTerm Term to find in page\n     * @param options Search options\n     *\n     * Note: By default, each subsequent call will highlight the next text that matches the search term.\n     *\n     * Returns a promise with the results for the request. By subscribing to the\n     * found-in-page event, you can get the results of this call as well.\n     *\n     * @example\n     * View:\n     * ```js\n     * const view = fin.View.getCurrentSync();\n     *\n     * //By subscribing to the 'found in page' event we can get the results of each findInPage call made.\n     * view.addListener('found-in-page', (event) => {\n     *     console.log(event);\n     * });\n     *\n     * // The promise also returns the results for the request\n     * view.findInPage('a').then((result) => {\n     *     console.log(result)\n     * });\n     * ```\n     *\n     * Window:\n     * ```js\n     * const win = fin.Window.getCurrentSync();\n     *\n     * //By subscribing to the 'found in page' event we can get the results of each findInPage call made.\n     * win.addListener('found-in-page', (event) => {\n     *     console.log(event);\n     * });\n     *\n     * // The promise also returns the results for the request\n     * win.findInPage('a').then((result) => {\n     *     console.log(result)\n     * });\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    findInPage(searchTerm, options) {\n        return this.wire\n            .sendAction('find-in-page', { ...this.identity, searchTerm, options })\n            .then(({ payload }) => payload.data);\n    }\n    /**\n     * Stop a {@link View#findInPage findInPage} call by specifying any of these actions:\n     *\n     * * clearSelection - Clear the selection.\n     * * keepSelection - Translate the selection into a normal selection.\n     * * activateSelection - Focus and click the selection node.\n     *\n     * @example\n     * View:\n     * ```js\n     * const view = fin.View.getCurrentSync();\n     *\n     * view.addListener('found-in-page', (event) => {\n     *     setTimeout(() => {\n     *         view.stopFindInPage('clearSelection');\n     *     }, 5000);\n     * });\n     *\n     * view.findInPage('a').then(results => {\n     *     console.log(results);\n     * });\n     * ```\n     *\n     * Window:\n     * ```js\n     * const win = fin.Window.getCurrentSync();\n     *\n     * win.addListener('found-in-page', (event) => {\n     *     setTimeout(() => {\n     *         win.stopFindInPage('clearSelection');\n     *     }, 5000);\n     * });\n     *\n     * win.findInPage('a').then(results => {\n     *     console.log(results);\n     * });\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    stopFindInPage(action) {\n        return this.wire.sendAction('stop-find-in-page', { ...this.identity, action }).then(() => undefined);\n    }\n    /**\n     * Returns an array with all system printers\n     * @deprecated use System.getPrinters instead\n     *\n     * @example\n     * View:\n     * ```js\n     * const view = fin.View.getCurrentSync();\n     *\n     * view.getPrinters()\n     *     .then((printers) => {\n     *         printers.forEach((printer) => {\n     *             if (printer.isDefault) {\n     *                 console.log(printer);\n     *             }\n     *         });\n     *     })\n     *     .catch((err) => {\n     *         console.log(err);\n     *     });\n     * ```\n     *\n     * Window:\n     * ```js\n     * const win = fin.Window.getCurrentSync();\n     *\n     * win.getPrinters()\n     *     .then((printers) => {\n     *         printers.forEach((printer) => {\n     *             if (printer.isDefault) {\n     *                 console.log(printer);\n     *             }\n     *         });\n     *     })\n     *     .catch((err) => {\n     *         console.log(err);\n     *     });\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    getPrinters() {\n        return this.wire.sendAction('get-printers', { ...this.identity }).then(({ payload }) => payload.data);\n    }\n    /**\n     * Gives focus to the WebContents.\n     *\n     * @example\n     * ```js\n     * async function focusWindow() {\n     *     const app = await fin.Application.start({\n     *         name: 'myApp',\n     *         uuid: 'app-1',\n     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.focus.html',\n     *         autoShow: true\n     *     });\n     *     const win = await app.getWindow();\n     *     return await win.focus();\n     * }\n     *\n     * focusWindow().then(() => console.log('Window focused')).catch(err => console.log(err));\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    async focus({ emitSynthFocused } = { emitSynthFocused: true }) {\n        await this.wire.sendAction('focus-window', { emitSynthFocused, ...this.identity });\n    }\n    /**\n     * Shows the Chromium Developer Tools\n     *\n     * @example\n     * View:\n     * ```js\n     * async function showDeveloperTools() {\n     *     const view = await fin.View.getCurrent();\n     *     return view.showDeveloperTools();\n     * }\n     *\n     * showDevelopertools()\n     * .then(() => console.log('Showing dev tools'))\n     * .catch(err => console.error(err));\n     * ```\n     *\n     * Window:\n     * ```js\n     * async function showDeveloperTools() {\n     *     const win = await fin.Window.getCurrent();\n     *     return win.showDeveloperTools();\n     * }\n     *\n     * showDevelopertools()\n     * .then(() => console.log('Showing dev tools'))\n     * .catch(err => console.error(err));\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    async showDeveloperTools() {\n        // Note this hits the system action map in core state for legacy reasons.\n        await this.wire.sendAction('show-developer-tools', this.identity);\n    }\n    /**\n     * Retrieves the process information associated with a WebContents.\n     *\n     * Note: This includes any iframes associated with the WebContents\n     *\n     * @example\n     * View:\n     * ```js\n     *     const view = await fin.View.getCurrent();\n     *     const processInfo = await view.getProcessInfo();\n     * ```\n     *\n     * Window:\n     * ```js\n     *     const win = await fin.Window.getCurrent();\n     *     const processInfo = await win.getProcessInfo();\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    async getProcessInfo() {\n        const { payload: { data } } = await this.wire.sendAction('get-process-info', this.identity);\n        return data;\n    }\n    /**\n     * Retrieves information on all Shared Workers.\n     *\n     * @example\n     * View:\n     * ```js\n     *     const view = await fin.View.create({\n     *         name: 'viewName',\n     *         target: fin.me.identity,\n     *         bounds: {top: 10, left: 10, width: 200, height: 200}\n     *     });\n     *\n     *     await view.navigate('https://mdn.github.io/dom-examples/web-workers/simple-shared-worker/');\n     *\n     *     const sharedWorkers = await view.getSharedWorkers();\n     * ```\n     *\n     * Window:\n     * ```js\n     *     const winOption = {\n     *         name:'child',\n     *         defaultWidth: 300,\n     *         defaultHeight: 300,\n     *         url: 'https://mdn.github.io/dom-examples/web-workers/simple-shared-worker/',\n     *         frame: true,\n     *         autoShow: true\n     *     };\n     *     const win = await fin.Window.create(winOption);\n     *     const sharedWorkers = await win.getSharedWorkers();\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    async getSharedWorkers() {\n        return this.wire.sendAction('get-shared-workers', this.identity).then(({ payload }) => payload.data);\n    }\n    /**\n     * Opens the developer tools for the shared worker context.\n     *\n     * @example\n     * View:\n     * ```js\n     *     const view = await fin.View.create({\n     *         name: 'viewName',\n     *         target: fin.me.identity,\n     *         bounds: {top: 10, left: 10, width: 200, height: 200}\n     *     });\n     *\n     *     await view.navigate('https://mdn.github.io/dom-examples/web-workers/simple-shared-worker/');\n     *\n     *     await view.inspectSharedWorker();\n     * ```\n     *\n     * Example:\n     * ```js\n     *     const winOption = {\n     *         name:'child',\n     *         defaultWidth: 300,\n     *         defaultHeight: 300,\n     *         url: 'https://mdn.github.io/dom-examples/web-workers/simple-shared-worker/',\n     *         frame: true,\n     *         autoShow: true\n     *     };\n     *     const win = await fin.Window.create(winOption);\n     *     await win.inspectSharedWorker();\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    async inspectSharedWorker() {\n        await this.wire.sendAction('inspect-shared-worker', { ...this.identity });\n    }\n    /**\n     * Inspects the shared worker based on its ID.\n     * @param workerId - The id of the shared worker.\n     *\n     * @example\n     * View:\n     * ```js\n     *     const view = await fin.View.create({\n     *         name: 'viewName',\n     *         target: fin.me.identity,\n     *         bounds: {top: 10, left: 10, width: 200, height: 200}\n     *     });\n     *\n     *     await view.navigate('https://mdn.github.io/dom-examples/web-workers/simple-shared-worker/');\n     *\n     *     const sharedWorkers = await view.getSharedWorkers();\n     *     await view.inspectSharedWorkerById(sharedWorkers[0].id);\n     * ```\n     *\n     * Window:\n     * ```js\n     *     const winOption = {\n     *         name:'child',\n     *         defaultWidth: 300,\n     *         defaultHeight: 300,\n     *         url: 'https://mdn.github.io/dom-examples/web-workers/simple-shared-worker/',\n     *         frame: true,\n     *         autoShow: true\n     *     };\n     *     const win = await fin.Window.create(winOption);\n     *     const sharedWorkers = await win.getSharedWorkers();\n     *     await win.inspectSharedWorkerById(sharedWorkers[0].id);\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    async inspectSharedWorkerById(workerId) {\n        await this.wire.sendAction('inspect-shared-worker-by-id', { ...this.identity, workerId });\n    }\n    /**\n     * Opens the developer tools for the service worker context.\n     *\n     * @example\n     * View:\n     * ```js\n     *     const view = await fin.View.create({\n     *         name: 'viewName',\n     *         target: fin.me.identity,\n     *         bounds: {top: 10, left: 10, width: 200, height: 200}\n     *     });\n     *\n     *     await view.navigate('http://googlechrome.github.io/samples/service-worker/basic/index.html');\n     *\n     *     await view.inspectServiceWorker();\n     * ```\n     *\n     * Window:\n     * ```js\n     *     const winOption = {\n     *         name:'child',\n     *         defaultWidth: 300,\n     *         defaultHeight: 300,\n     *         url: 'http://googlechrome.github.io/samples/service-worker/basic/index.html',\n     *         frame: true,\n     *         autoShow: true\n     *     };\n     *     const win = await fin.Window.create(winOption);\n     *     await win.inspectServiceWorker();\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    async inspectServiceWorker() {\n        await this.wire.sendAction('inspect-service-worker', { ...this.identity });\n    }\n    /**\n     * Shows a popup window.\n     *\n     * Note: If this WebContents is a view and its attached window has a popup open, this will close it.\n     *\n     * Shows a popup window. Including a `name` in `options` will attempt to show an existing window as a popup, if\n     * that window doesn't exist or no `name` is included a window will be created. If the caller view or the caller\n     * view's parent window currently has a popup window open, calling `showPopupWindow` again will dismiss the currently\n     * open popup window before showing the new popup window. Also, if the caller view is destroyed or detached, the popup\n     * will be dismissed.\n     *\n     * Note: in the case where the window being shown as a popup needs to be created, it is a child of the caller view's parent window.\n     *\n     * @example\n     *\n     * Create and show a single-use popup window that returns a single result to the caller. `initialOptions` allows\n     * us to pass window options to the popup window that will be created. `resultDispatchBehavior: 'close'` ensures\n     * that once the popup window calls `dispatchPopupResult` it is closed. `blurBehavior: 'close'` will yield a dismissed\n     * result should the popup window lose focus.\n     *\n     * ```js\n     * const result = await fin.me.showPopupWindow({\n     *     initialOptions: {\n     *         frame: false\n     *     },\n     *     url: '<my_popup_url>',\n     *     resultDispatchBehavior: 'close',\n     *     blurBehavior: 'close',\n     *     focus: true,\n     *     height: 300,\n     *     width: 300,\n     *     x: 0,\n     *     y: 0\n     * });\n     * ```\n     *\n     * Same as above but using an existing window as a popup by referencing its `name`:\n     *\n     * Note: if a window with the `name` provided doesn't exist, it will be created.\n     *\n     * ```js\n     * const result = await fin.me.showPopupWindow({\n     *     initialOptions: {\n     *         frame: true\n     *     },\n     *     name: 'my-popup', // shows the 'my-popup' window if it exists, otherwise creates it\n     *     url: '<my_popup_url>', // navigates to this url if it doesn't match the location.href of the 'my-popup' window\n     *     resultDispatchBehavior: 'close',\n     *     blurBehavior: 'close',\n     *     focus: true,\n     *     hideOnClose: true, // persist window on 'dismissed' result, alternatively change onResultDispatch and blurBehavior to 'hide'\n     *     height: 300,\n     *     width: 300,\n     *     x: 0,\n     *     y: 0\n     * });\n     * ```\n     *\n     * Create and show a popup window that is able to return multiple results to the caller via an `onPopupResult` callback. Each\n     * time the popup window calls `dispatchPopupResult`, the callback will be executed on the result. Once the popup window is\n     * closed or hidden, the `showPopupWindow` promise will resolve with a `dismissed` result that will include the most recently\n     * dispatched result as `lastDispatchResult`:\n     *\n     * ```js\n     * const popupResultCallback = (payload) => {\n     *        if (payload.result === 'clicked') {\n     *            if (payload.data.topic === 'color-changed') {\n     *                // do something like\n     *                // setColor(payload.data.value);\n     *            }\n     *        }\n     * };\n     *\n     * await fin.me.showPopupWindow({\n     *     initialOptions: {\n     *         frame: false\n     *     },\n     *     url: '<my_popup_url>',\n     *     resultDispatchBehavior: 'none',\n     *     blurBehavior: 'close',\n     *     focus: true,\n     *     height: 300,\n     *     width: 300,\n     *     x: 0,\n     *     y: 0,\n     *     onPopupResult: popupResultCallback\n     * });\n     * ```\n     *\n     * Same as above but using an existing window as a popup:\n     *\n     * ```js\n     * const popupResultCallback = (payload) => {\n     *        if (payload.result === 'clicked') {\n     *            if (payload.data.topic === 'color-changed') {\n     *                // do something like\n     *                // setColor(payload.data.value);\n     *            }\n     *        }\n     * };\n     *\n     * await fin.me.showPopupWindow({\n     *     initialOptions: {\n     *         frame: false\n     *     },\n     *     name: 'my-popup', // shows the 'my-popup' window if it exists, otherwise creates it\n     *     url: '<my_popup_url>', // navigates to this url if it doesn't match the location.href of the 'my-popup' window\n     *     resultDispatchBehavior: 'none',\n     *     blurBehavior: 'hide',\n     *     focus: true,\n     *     hideOnClose: true, // we can just use this or we can change blurBehavior to 'hide'\n     *     height: 300,\n     *     width: 300,\n     *     x: 0,\n     *     y: 0,\n     *     onPopupResult: popupResultCallback\n     * });\n     * ```\n     *\n     * Create or show a popup window that disables user movement (positioning and resizing) in the caller\n     * view's parent window by using `blurBehavior: 'modal'`:\n     *\n     * ```js\n     * const result = await fin.me.showPopupWindow({\n     *     initialOptions: {\n     *         frame: false\n     *     },\n     *     url: '<my_popup_url>',\n     *     resultDispatchBehavior: 'close',\n     *     blurBehavior: 'modal',\n     *     focus: true,\n     *     height: 300,\n     *     width: 300,\n     *     x: 0,\n     *     y: 0\n     * });\n     * ```\n     *\n     * Create a popup window as a modal:\n     *\n     * Note: The only way to ensure true modal behavior is to create the window being shown as a popup with a\n     * `modalParentIdentity` that uses the caller view's parent window identity.\n     *\n     * ```js\n     * const result = await fin.me.showPopupWindow({\n     *     initialOptions: {\n     *         frame: false,\n     *         modalParentIdentity: fin.me.identity\n     *     },\n     *     url: '<my_popup_url>',\n     *     resultDispatchBehavior: 'close',\n     *     blurBehavior: 'modal',\n     *     focus: true,\n     *     height: 300,\n     *     width: 300,\n     *     x: 0,\n     *     y: 0\n     * });\n     * ```\n     *\n     * Pass data to a popup window that is available when the popup is shown.\n     *\n     * Note: this is just one example for a use of `additionalOptions`, it can be used to update any updatable\n     * window options when creating or showing an existing window as a popup.\n     *\n     * ```js\n     * const result = await fin.me.showPopupWindow({\n     *     additionalOptions: {\n     *         customData: {\n     *             foo: 'bar'\n     *         }\n     *     },\n     *     url: '<my_popup_url>',\n     *     resultDispatchBehavior: 'close',\n     *     blurBehavior: 'close',\n     *     focus: true,\n     *     height: 300,\n     *     width: 300,\n     *     x: 0,\n     *     y: 0\n     * });\n     *\n     * // Access from the popup window context like so:\n     * const { customData } = await fin.me.getOptions();\n     * const { foo } = customData;\n     * ```\n     *\n     * Execute a callback on the popup's OpenFin window when the popup is shown:\n     *\n     * ```js\n     * const popupWindowCallback = async (win) => {\n     *     await win.flash();\n     * };\n     *\n     * const result = await fin.me.showPopupWindow({\n     *     url: '<my_popup_url>',\n     *     resultDispatchBehavior: 'close',\n     *     blurBehavior: 'close',\n     *     focus: true,\n     *     height: 300,\n     *     width: 300,\n     *     x: 0,\n     *     y: 0,\n     *     onPopupReady: popupWindowCallback;\n     * });\n     * ```\n     * @remarks\n     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.\n     * We do not expose an explicit superclass for this functionality, but it does have its own\n     * {@link OpenFin.WebContentsEvents event namespace}.\n     */\n    async showPopupWindow(options) {\n        this.wire.sendAction(`${this.entityType}-show-popup-window`, this.identity).catch(() => {\n            // we do not want to expose this error, just continue if this analytics-only call fails\n        });\n        if (options?.onPopupReady) {\n            const readyListener = async ({ popupName }) => {\n                try {\n                    const popupWindow = this.fin.Window.wrapSync({ uuid: this.fin.me.uuid, name: popupName });\n                    await options.onPopupReady(popupWindow);\n                }\n                catch (error) {\n                    throw new Error(`Something went wrong during onPopupReady execution: ${error}`);\n                }\n            };\n            // TODO: fix typing (internal)\n            // @ts-expect-error\n            await this.once('popup-ready', readyListener);\n        }\n        const { payload: tryCreatePayload } = await this.wire.sendAction('try-create-popup-window', {\n            options: {\n                ...options,\n                // Internal use only.\n                // @ts-expect-error\n                hasResultCallback: !!options?.onPopupResult,\n                hasReadyCallback: !!options?.onPopupReady\n            },\n            ...this.identity\n        });\n        const { data: { willOpen, options: popupOptions } } = tryCreatePayload;\n        if (willOpen) {\n            // Solve the issue where Interop in a popup window with non cross-origin url is not working(core-1076).\n            await this.fin.Window.create(popupOptions.initialOptions);\n        }\n        const normalizePopupResult = (payload) => {\n            const { name, uuid, result, data } = payload;\n            const popupResult = {\n                identity: {\n                    name,\n                    uuid\n                },\n                result\n            };\n            if (data) {\n                popupResult.data = data;\n            }\n            return popupResult;\n        };\n        if (options?.onPopupResult) {\n            const dispatchResultListener = async (payload) => {\n                await options.onPopupResult(normalizePopupResult(payload));\n            };\n            const teardownListener = async () => {\n                // TODO: fix typing (internal)\n                // @ts-expect-error\n                await this.removeListener('popup-result', dispatchResultListener);\n            };\n            // TODO: fix typing (internal)\n            // @ts-expect-error\n            await this.on('popup-result', dispatchResultListener);\n            // TODO: fix typing (internal)\n            // hilariously this does not need a ts-expect-error - this is gap in type soundness\n            // should investigate - probably due to `teardownListener` taking a void argument\n            // which might play nicely with the `never` type?  huh...\n            await this.once('popup-teardown', teardownListener);\n        }\n        const { payload } = await this.wire.sendAction('show-popup-window', {\n            options: popupOptions,\n            ...this.identity\n        });\n        return payload.data;\n    }\n}\nmain.WebContents = WebContents;\n\nvar hasRequiredInstance$2;\n\nfunction requireInstance$2 () {\n\tif (hasRequiredInstance$2) return Instance$5;\n\thasRequiredInstance$2 = 1;\n\tvar __classPrivateFieldGet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n\t    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n\t    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n\t    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n\t};\n\tvar _View_providerChannelClient;\n\tObject.defineProperty(Instance$5, \"__esModule\", { value: true });\n\tInstance$5.View = void 0;\n\tconst transport_errors_1 = transportErrors;\n\tconst lazy_1 = lazy;\n\tconst layout_entities_1 = layoutEntities;\n\tconst layout_constants_1 = layout_constants;\n\tconst main_1 = main;\n\tconst window_1 = requireWindow();\n\t/**\n\t * A View can be used to embed additional web content into a Window.\n\t * It is like a child window, except it is positioned relative to its owning window.\n\t * It has the ability to listen for {@link OpenFin.ViewEvents View-specific events}.\n\t *\n\t * By default, a View will try to share the same renderer process as other Views owned by its parent Application.\n\t * To change that behavior, see the processAffinity {@link OpenFin.ViewOptions view option}.\n\t *\n\t * A View's lifecycle is tied to its owning window and can be re-attached to a different window at any point during its lifecycle.\n\t */\n\tclass View extends main_1.WebContents {\n\t    /**\n\t     * @internal\n\t     */\n\t    constructor(wire, identity) {\n\t        super(wire, identity, 'view');\n\t        this.identity = identity;\n\t        _View_providerChannelClient.set(this, new lazy_1.Lazy(() => {\n\t            const platform = this.fin.Platform.wrapSync(this.identity);\n\t            return platform.getClient();\n\t        }));\n\t        /**\n\t         * Attaches the current view to the given window identity.\n\t         * Identity must be the identity of a window in the same application.\n\t         * This detaches the view from its current window, and sets the view to be destroyed when its new window closes.\n\t         *\n\t         * @example\n\t         * ```js\n\t         * let view;\n\t         * async function createView() {\n\t         *     const me = await fin.Window.getCurrent();\n\t         *     return fin.View.create({\n\t         *         name: 'viewNameAttach',\n\t         *         target: me.identity,\n\t         *         bounds: {top: 10, left: 10, width: 200, height: 200}\n\t         *     });\n\t         * }\n\t         *\n\t         * async function attachView() {\n\t         *     view = await createView();\n\t         *     console.log('View created.');\n\t         *\n\t         *     await view.navigate('https://google.com');\n\t         *     console.log('View navigated to given url.');\n\t         *\n\t         *     const winOption = {\n\t         *         name:'winOptionName',\n\t         *         defaultWidth: 300,\n\t         *         defaultHeight: 300,\n\t         *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.create.html',\n\t         *         frame: true,\n\t         *         autoShow: true\n\t         *     };\n\t         *     const newWindow = await fin.Window.create(winOption);\n\t         *     view.attach(newWindow.identity);\n\t         * }\n\t         *\n\t         * attachView()\n\t         *     .then(() => console.log('View attached to new window.'))\n\t         *     .catch(err => console.log(err));\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.attach = async (target) => {\n\t            await this.wire.sendAction('attach-view', { target, ...this.identity });\n\t        };\n\t        /**\n\t         * Destroys the current view\n\t         *\n\t         * @example\n\t         * ```js\n\t         * const view = fin.View.wrapSync({ uuid: 'viewUuid', name: 'viewName' });\n\t         * view.destroy();\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.destroy = async () => {\n\t            await this.wire.sendAction('destroy-view', { ...this.identity });\n\t        };\n\t        /**\n\t         * Shows the current view if it is currently hidden.\n\t         *\n\t         * @example\n\t         * ```js\n\t         * let view;\n\t         * async function createView() {\n\t         *     const me = await fin.Window.getCurrent();\n\t         *     return fin.View.create({\n\t         *         name: 'viewNameShow',\n\t         *         target: me.identity,\n\t         *         bounds: {top: 10, left: 10, width: 200, height: 200}\n\t         *     });\n\t         * }\n\t         *\n\t         * async function hideAndShowView() {\n\t         *     view = await createView();\n\t         *     console.log('View created.');\n\t         *\n\t         *     await view.navigate('https://google.com');\n\t         *     console.log('View navigated to given url option.');\n\t         *\n\t         *     await view.hide();\n\t         *     console.log(\"View hidden.\");\n\t         *\n\t         *     view.show();\n\t         *     console.log(\"View shown.\");\n\t         * }\n\t         *\n\t         * hideAndShowView()\n\t         *     .then(() => console.log('View hidden and shown.'))\n\t         *     .catch(err => console.log(err));\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.show = async () => {\n\t            await this.wire.sendAction('show-view', { ...this.identity });\n\t        };\n\t        /**\n\t         * Sets the bounds (top, left, width, height) of the view relative to its window and shows it if it is hidden.\n\t         * This method ensures the view is both positioned and showing. It will reposition a visible view and both show and reposition a hidden view.\n\t         *\n\t         * @remarks View position is relative to the bounds of the window.\n\t         * ({top: 0, left: 0} represents the top left corner of the window)\n\t         *\n\t         * @example\n\t         * ```js\n\t         * let view;\n\t         * async function createView() {\n\t         *     const me = await fin.Window.getCurrent();\n\t         *     return fin.View.create({\n\t         *         name: 'viewNameSetBounds',\n\t         *         target: me.identity,\n\t         *         bounds: {top: 10, left: 10, width: 200, height: 200}\n\t         *     });\n\t         * }\n\t         *\n\t         * async function showViewAt() {\n\t         *     view = await createView();\n\t         *     console.log('View created.');\n\t         *\n\t         *     await view.navigate('https://google.com');\n\t         *     console.log('View navigated to given url.');\n\t         *\n\t         *     await view.showAt({\n\t         *         top: 100,\n\t         *         left: 100,\n\t         *         width: 300,\n\t         *         height: 300\n\t         *     }, {\n\t         *       bringToFront : true\n\t         *     });\n\t         * }\n\t         *\n\t         * showViewAt()\n\t         *     .then(() => console.log('View set to new bounds and shown.'))\n\t         *     .catch(err => console.log(err));\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.showAt = async (bounds, options = {}) => {\n\t            await this.wire.sendAction('show-view-at', { bounds, ...this.identity, options });\n\t        };\n\t        /**\n\t         * Brings the specified view to the front of its current window. This ensures the view will be visible on top of any other views\n\t         * which have overlapping bounds with it.\n\t         *\n\t         * Please note, this is not a permanent action - when a new view is created or attached to the window, it will display on top of all other views\n\t         * in the window that share bounds with it.\n\t         */\n\t        this.bringToFront = async () => {\n\t            await this.wire.sendAction('bring-view-to-front', { ...this.identity });\n\t        };\n\t        /**\n\t         * Hides the current view if it is currently visible.\n\t         *\n\t         * @example\n\t         * ```js\n\t         * let view;\n\t         * async function createView() {\n\t         *     const me = await fin.Window.getCurrent();\n\t         *     return fin.View.create({\n\t         *         name: 'viewNameHide',\n\t         *         target: me.identity,\n\t         *         bounds: {top: 10, left: 10, width: 200, height: 200}\n\t         *     });\n\t         * }\n\t         *\n\t         * async function hideView() {\n\t         *     view = await createView();\n\t         *     console.log('View created.');\n\t         *\n\t         *     await view.navigate('https://google.com');\n\t         *     console.log('View navigated to given url.');\n\t         *\n\t         *     await view.hide();\n\t         * }\n\t         *\n\t         * hideView()\n\t         *     .then(() => console.log('View hidden.'))\n\t         *     .catch(err => console.log(err));\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.hide = async () => {\n\t            await this.wire.sendAction('hide-view', { ...this.identity });\n\t        };\n\t        /**\n\t         * Sets the bounds (top, left, width, height) of the view relative to its window.\n\t         *\n\t         * @remarks View position is relative to the bounds of the window.\n\t         * ({top: 0, left: 0} represents the top left corner of the window)\n\t         *\n\t         * @example\n\t         * ```js\n\t         * let view;\n\t         * async function createView() {\n\t         *     const me = await fin.Window.getCurrent();\n\t         *     return fin.View.create({\n\t         *         name: 'viewNameSetBounds',\n\t         *         target: me.identity,\n\t         *         bounds: {top: 10, left: 10, width: 200, height: 200}\n\t         *     });\n\t         * }\n\t         *\n\t         * async function setViewBounds() {\n\t         *     view = await createView();\n\t         *     console.log('View created.');\n\t         *\n\t         *     await view.navigate('https://google.com');\n\t         *     console.log('View navigated to given url.');\n\t         *\n\t         *     await view.setBounds({\n\t         *         top: 100,\n\t         *         left: 100,\n\t         *         width: 300,\n\t         *         height: 300\n\t         *     });\n\t         * }\n\t         *\n\t         * setViewBounds()\n\t         *     .then(() => console.log('View set to new bounds.'))\n\t         *     .catch(err => console.log(err));\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.setBounds = async (bounds) => {\n\t            await this.wire.sendAction('set-view-bounds', { bounds, ...this.identity });\n\t        };\n\t        /**\n\t         * Gets the bounds (top, left, width, height) of the view relative to its window.\n\t         *\n\t         * @remarks View position is relative to the bounds of the window.\n\t         * ({top: 0, left: 0} represents the top left corner of the window)\n\t         *\n\t         * @example\n\t         * ```js\n\t         * const view = await fin.View.create({\n\t         *     name: 'viewNameSetBounds',\n\t         *     target: fin.me.identity,\n\t         *     bounds: {top: 10, left: 10, width: 200, height: 200}\n\t         * });\n\t         *\n\t         * await view.navigate('https://google.com');\n\t         *\n\t         * await view.setBounds({\n\t         *     top: 100,\n\t         *     left: 100,\n\t         *     width: 300,\n\t         *     height: 300\n\t         * });\n\t         *\n\t         * console.log(await view.getBounds());\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.getBounds = async () => {\n\t            const ack = await this.wire.sendAction('get-view-bounds', { ...this.identity });\n\t            return ack.payload.data;\n\t        };\n\t        /**\n\t         * Gets the View's info.\n\t         *\n\t         * @example\n\t         * ```js\n\t         * let view;\n\t         * async function createView() {\n\t         *     const me = await fin.Window.getCurrent();\n\t         *     return fin.View.create({\n\t         *         name: 'viewNameGetInfo',\n\t         *         target: me.identity,\n\t         *         bounds: {top: 10, left: 10, width: 200, height: 200}\n\t         *     });\n\t         * }\n\t         *\n\t         * async function getViewInfo() {\n\t         *     view = await createView();\n\t         *     console.log('View created.');\n\t         *\n\t         *     await view.navigate('https://google.com');\n\t         *     console.log('View navigated to given url.');\n\t         *\n\t         *     return view.getInfo();\n\t         * }\n\t         *\n\t         * getViewInfo()\n\t         *     .then((info) => console.log('View info fetched.', info))\n\t         *     .catch(err => console.log(err));\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.getInfo = async () => {\n\t            const ack = await this.wire.sendAction('get-view-info', { ...this.identity });\n\t            return ack.payload.data;\n\t        };\n\t        /**\n\t         * Retrieves the layout for the window the view is attached to.\n\t         *\n\t         * @example\n\t         * ```js\n\t         *     //get the current View\n\t         *     const view = await fin.View.getCurrent();\n\t         *\n\t         *     //get a reference to the Layout for the Window the view is part of\n\t         *     const layout = await view.getParentLayout();\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.getParentLayout = async () => {\n\t            this.wire.sendAction('view-get-parent-layout', { ...this.identity }).catch(() => {\n\t                // don't expose\n\t            });\n\t            const layoutWindow = await this.getCurrentWindow();\n\t            let layoutWindowIdentity = layoutWindow.identity;\n\t            // TODO: CORE-1857 - when we tearout active layout or drag a view out of a window, the above identity includes the whole window info.\n\t            if (layoutWindowIdentity.identity) {\n\t                layoutWindowIdentity = layoutWindowIdentity.identity;\n\t            }\n\t            try {\n\t                const providerChannelClient = await __classPrivateFieldGet(this, _View_providerChannelClient, \"f\").getValue();\n\t                const client = await layout_entities_1.LayoutNode.newLayoutEntitiesClient(providerChannelClient, layout_constants_1.LAYOUT_CONTROLLER_ID, layoutWindowIdentity);\n\t                const layoutIdentity = await client.getLayoutIdentityForViewOrThrow(this.identity);\n\t                return this.fin.Platform.Layout.wrap(layoutIdentity);\n\t            }\n\t            catch (e) {\n\t                const allowedErrors = [\n\t                    'No action registered at target for',\n\t                    'getLayoutIdentityForViewOrThrow is not a function'\n\t                ];\n\t                if (!allowedErrors.some((m) => e.message.includes(m))) {\n\t                    throw e;\n\t                }\n\t                // fallback logic for missing endpoint\n\t                return this.fin.Platform.Layout.wrap(layoutWindowIdentity);\n\t            }\n\t        };\n\t        /**\n\t         * Gets the View's options.\n\t         *\n\t         * @example\n\t         * ```js\n\t         * let view;\n\t         * async function createView() {\n\t         *     const me = await fin.Window.getCurrent();\n\t         *     return fin.View.create({\n\t         *         name: 'viewNameGetOptions',\n\t         *         target: me.identity,\n\t         *         bounds: {top: 10, left: 10, width: 200, height: 200}\n\t         *     });\n\t         * }\n\t         *\n\t         * async function getViewOptions() {\n\t         *     view = await createView();\n\t         *     console.log('View created.');\n\t         *\n\t         *     await view.navigate('https://google.com');\n\t         *     console.log('View navigated to given url.');\n\t         *\n\t         *     const me = await fin.Window.getCurrent();\n\t         *     view = fin.View.wrapSync({ uuid: me.identity.uuid, name: 'viewNameGetOptions' });\n\t         *     return view.getOptions();\n\t         * }\n\t         *\n\t         * getViewOptions()\n\t         *     .then((info) => console.log('View options fetched.', info))\n\t         *     .catch(err => console.log(err));\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.getOptions = async () => {\n\t            return this.wire.sendAction('get-view-options', { ...this.identity }).then(({ payload }) => payload.data);\n\t        };\n\t        /**\n\t         * Updates the view's options.\n\t         *\n\t         * @example\n\t         * ```js\n\t         * let view;\n\t         * async function createView() {\n\t         *     const me = await fin.Window.getCurrent();\n\t         *     return fin.View.create({\n\t         *         url: 'https://google.com',\n\t         *         name: 'viewNameUpdateOptions',\n\t         *         target: me.identity,\n\t         *         bounds: {top: 10, left: 10, width: 200, height: 200}\n\t         *     });\n\t         * }\n\t         *\n\t         * async function updateViewOptions() {\n\t         *     view = await createView();\n\t         *     console.log('View created.');\n\t         *\n\t         *     await view.navigate('https://google.com');\n\t         *     console.log('View navigated to given url option.');\n\t         *\n\t         *     const newOptions = { autoResize: {\n\t         *         width: true,\n\t         *         horizontal: true\n\t         *     }};\n\t         *     return view.updateOptions(newOptions);\n\t         * }\n\t         *\n\t         * updateViewOptions()\n\t         *     .then(payload => console.log('View options updated: ', payload))\n\t         *     .catch(err => console.log(err));\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.updateOptions = async (options) => {\n\t            return this.wire.sendAction('update-view-options', { options, ...this.identity }).then(() => undefined);\n\t        };\n\t        /**\n\t         * Retrieves the window the view is currently attached to.\n\t         *\n\t         * @example\n\t         * ```js\n\t         * const view = fin.View.wrapSync({ uuid: 'viewUuid', name: 'viewName' });\n\t         * view.getCurrentWindow()\n\t         *     .then(win => console.log('current window', win))\n\t         *     .catch(err => console.log(err));)\n\t         * ```\n\t         * @experimental\n\t         */\n\t        this.getCurrentWindow = async () => {\n\t            const { payload: { data } } = await this.wire.sendAction('get-view-window', { ...this.identity });\n\t            return new window_1._Window(this.wire, data);\n\t        };\n\t        /**\n\t         * Retrieves the current {@link OpenFin.TabStack} of the view if it belongs to one.\n\t         * @returns this view belongs to.\n\t         * @throws if this view does not belong to a TabStack or if the window has been destroyed.\n\t         * @example\n\t         * ```js\n\t         * if (!fin.me.isView) {\n\t         *     throw new Error('Not running in a platform View.');\n\t         * }\n\t         *\n\t         * const stack = await fin.me.getCurrentStack();\n\t         * // Alternatively, you can wrap any view and get the stack from there\n\t         * // const viewFromSomewhere = fin.View.wrapSync(someView.identity);\n\t         * // const stack = await viewFromSomewhere.getCurrentStack();\n\t         * const views = await stack.getViews();\n\t         * console.log(`Stack contains ${views.length} view(s)`);\n\t         * ```\n\t         */\n\t        this.getCurrentStack = async () => {\n\t            this.wire.sendAction('view-get-current-stack').catch(() => {\n\t                // don't expose\n\t            });\n\t            try {\n\t                const layoutWindow = await this.getCurrentWindow();\n\t                const providerChannelClient = await __classPrivateFieldGet(this, _View_providerChannelClient, \"f\").getValue();\n\t                const client = await layout_entities_1.LayoutNode.newLayoutEntitiesClient(providerChannelClient, layout_constants_1.LAYOUT_CONTROLLER_ID, layoutWindow.identity);\n\t                const stackDefinition = (await client.getStackByView(this.identity));\n\t                return layout_entities_1.LayoutNode.getEntity(stackDefinition, client);\n\t            }\n\t            catch (error) {\n\t                throw new transport_errors_1.RuntimeError({ reason: 'This view does not belong to a stack.', error });\n\t            }\n\t        };\n\t        /**\n\t         * Triggers the before-unload handler for the View, if one is set.\n\t         *\n\t         * @remarks Returns `true` if the handler is trying to prevent the View from unloading, and `false` if it isn't.\n\t         * Only enabled when setting enableBeforeUnload: true in your View options. If this option is not enabled it will\n\t         * always return false.\n\t         *\n\t         * This method is used internally by the Platform Provider to determine the status of each before unload handler in Views when closing the Window.\n\t         *\n\t         * @example\n\t         *\n\t         * ```js\n\t         * // from inside a View context\n\t         * const unloadPrevented = await fin.me.triggerBeforeUnload();\n\t         * ```\n\t         *\n\t         * @experimental\n\t         */\n\t        this.triggerBeforeUnload = async () => {\n\t            const message = await this.wire.sendAction('trigger-before-unload', { ...this.identity });\n\t            return message.payload.data;\n\t        };\n\t        /**\n\t         * **NOTE**: Internal use only.\n\t         * Attaches this view to an HTML element in the current context. The view will resize responsively when the element bounds change.\n\t         *\n\t         * **Known issue**: View.bindToElement does not track position changes, if the element has fixed px width and height values it is possible for the view to not update responsively.\n\t         *\n\t         * **Known issue**: When View.bindToElement is used on a element that takes up the entire page in a platform window, the bound view will not respond responsively when the window is resized to be smaller.\n\t         *\n\t         * @param element - HTML element to attach the view to.\n\t         * @returns - Cleanup function that will disconnect the element resize observer.\n\t         * @internal\n\t         * @experimental\n\t         * @remarks View will resize accordingly when the element is resized. If the element is repositioned in the DOM the view will not be repositioned, to handle this case call `bindToElement` again once the element changes position.\n\t         *\n\t         * @example\n\t         * ```html\n\t         * <div id=\"view-container\"></div>\n\t         * <script>\n\t         *     async function createAndAttachView() {\n\t         *         const url = 'https://example.com';\n\t         *         const elementId = 'view-container';\n\t         *         const element = document.getElementById(elementId);\n\t         *         const view = await fin.View.create({\n\t         *             name: 'my-view',\n\t         *             url,\n\t         *             target: fin.me.identity\n\t         *         });\n\t         *         await view.navigate(url);\n\t         *         await view.bindToElement(element);\n\t         *     }\n\t         *     createAndAttachView().catch(console.error);\n\t         * </script>\n\t         * ```\n\t         */\n\t        this.bindToElement = async (element) => {\n\t            if (!element) {\n\t                throw new Error('Element not found.');\n\t            }\n\t            const onChange = async (bounds) => this.setBounds(bounds);\n\t            return this.wire.environment.observeBounds(element, onChange);\n\t        };\n\t    }\n\t    /**\n\t     * Focuses the view\n\t     *\n\t     * @example\n\t     * ```js\n\t     * const view = fin.View.wrapSync({ uuid: 'viewUuid', name: 'viewName' });\n\t     * await view.focus();\n\t     * // do things with the focused view\n\t     * ```\n\t     * @experimental\n\t     */\n\t    async focus({ emitSynthFocused } = { emitSynthFocused: true }) {\n\t        const win = await this.getCurrentWindow();\n\t        await win.focusedWebViewWasChanged();\n\t        await super.focus({ emitSynthFocused });\n\t    }\n\t}\n\tInstance$5.View = View;\n\t_View_providerChannelClient = new WeakMap();\n\treturn Instance$5;\n}\n\nvar hasRequiredView;\n\nfunction requireView () {\n\tif (hasRequiredView) return view;\n\thasRequiredView = 1;\n\t(function (exports) {\n\t\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t\t    if (k2 === undefined) k2 = k;\n\t\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t\t    }\n\t\t    Object.defineProperty(o, k2, desc);\n\t\t}) : (function(o, m, k, k2) {\n\t\t    if (k2 === undefined) k2 = k;\n\t\t    o[k2] = m[k];\n\t\t}));\n\t\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t\t};\n\t\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t\t/**\n\t\t * Entry points for the OpenFin `View` API (`fin.View`).\n\t\t *\n\t\t * * {@link ViewModule} contains static members of the `View` API, accessible through `fin.View`.\n\t\t * * {@link View} describes an instance of an OpenFin View, e.g. as returned by `fin.View.getCurrent`.\n\t\t *\n\t\t * These are separate code entities, and are documented separately.  In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/32.114.76.10/index.html),\n\t\t * both of these were documented on the same page.\n\t\t *\n\t\t * @packageDocumentation\n\t\t */\n\t\t__exportStar(requireFactory$3(), exports);\n\t\t__exportStar(requireInstance$2(), exports); \n\t} (view));\n\treturn view;\n}\n\nvar hasRequiredInstance$1;\n\nfunction requireInstance$1 () {\n\tif (hasRequiredInstance$1) return Instance$6;\n\thasRequiredInstance$1 = 1;\n\tObject.defineProperty(Instance$6, \"__esModule\", { value: true });\n\tInstance$6.Application = void 0;\n\t/* eslint-disable import/prefer-default-export */\n\tconst base_1 = base;\n\tconst window_1 = requireWindow();\n\tconst view_1 = requireView();\n\t/**\n\t * An object representing an application. Allows the developer to create,\n\t * execute, show/close an application as well as listen to {@link OpenFin.ApplicationEvents application events}.\n\t */\n\tclass Application extends base_1.EmitterBase {\n\t    /**\n\t     * @internal\n\t     */\n\t    constructor(wire, identity) {\n\t        super(wire, 'application', identity.uuid);\n\t        this.identity = identity;\n\t        this.window = new window_1._Window(this.wire, {\n\t            uuid: this.identity.uuid,\n\t            name: this.identity.uuid\n\t        });\n\t    }\n\t    windowListFromIdentityList(identityList) {\n\t        const windowList = [];\n\t        identityList.forEach((identity) => {\n\t            windowList.push(new window_1._Window(this.wire, {\n\t                uuid: identity.uuid,\n\t                name: identity.name\n\t            }));\n\t        });\n\t        return windowList;\n\t    }\n\t    /**\n\t     * Determines if the application is currently running.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function isAppRunning() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.isRunning();\n\t     * }\n\t     * isAppRunning().then(running => console.log(`Current app is running: ${running}`)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    isRunning() {\n\t        return this.wire.sendAction('is-application-running', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Closes the application and any child windows created by the application.\n\t     * Cleans the application from state so it is no longer found in getAllApplications.\n\t     * @param force Close will be prevented from closing when force is false and\n\t     *  ‘close-requested’ has been subscribed to for application’s main window.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function closeApp() {\n\t     *     const allApps1 = await fin.System.getAllApplications(); //[{uuid: 'app1', isRunning: true}, {uuid: 'app2', isRunning: true}]\n\t     *     const app = await fin.Application.wrap({uuid: 'app2'});\n\t     *     await app.quit();\n\t     *     const allApps2 = await fin.System.getAllApplications(); //[{uuid: 'app1', isRunning: true}]\n\t     *\n\t     * }\n\t     * closeApp().then(() => console.log('Application quit')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    async quit(force = false) {\n\t        try {\n\t            await this._close(force);\n\t            await this.wire.sendAction('destroy-application', { force, ...this.identity });\n\t        }\n\t        catch (error) {\n\t            const acceptableErrors = ['Remote connection has closed', 'Could not locate the requested application'];\n\t            if (!acceptableErrors.some((msg) => error.message.includes(msg))) {\n\t                throw error;\n\t            }\n\t        }\n\t    }\n\t    async _close(force = false) {\n\t        try {\n\t            await this.wire.sendAction('close-application', { force, ...this.identity });\n\t        }\n\t        catch (error) {\n\t            if (!error.message.includes('Remote connection has closed')) {\n\t                throw error;\n\t            }\n\t        }\n\t    }\n\t    /**\n\t     * @deprecated use Application.quit instead\n\t     * Closes the application and any child windows created by the application.\n\t     * @param force - Close will be prevented from closing when force is false and ‘close-requested’ has been subscribed to for application’s main window.\n\t     * @param callback - called if the method succeeds.\n\t     * @param errorCallback - called if the method fails. The reason for failure is passed as an argument.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function closeApp() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.close();\n\t     * }\n\t     * closeApp().then(() => console.log('Application closed')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    close(force = false) {\n\t        console.warn('Deprecation Warning: Application.close is deprecated Please use Application.quit');\n\t        this.wire.sendAction('application-close', this.identity).catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return this._close(force);\n\t    }\n\t    /**\n\t     * Retrieves an array of wrapped fin.Windows for each of the application’s child windows.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function getChildWindows() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.getChildWindows();\n\t     * }\n\t     *\n\t     * getChildWindows().then(children => console.log(children)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getChildWindows() {\n\t        return this.wire.sendAction('get-child-windows', this.identity).then(({ payload }) => {\n\t            const identityList = [];\n\t            payload.data.forEach((winName) => {\n\t                identityList.push({ uuid: this.identity.uuid, name: winName });\n\t            });\n\t            return this.windowListFromIdentityList(identityList);\n\t        });\n\t    }\n\t    /**\n\t     * Retrieves the JSON manifest that was used to create the application. Invokes the error callback\n\t     * if the application was not created from a manifest.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function getManifest() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.getManifest();\n\t     * }\n\t     *\n\t     * getManifest().then(manifest => console.log(manifest)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getManifest() {\n\t        return this.wire.sendAction('get-application-manifest', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Retrieves UUID of the application that launches this application. Invokes the error callback\n\t     * if the application was created from a manifest.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function getParentUuid() {\n\t     *     const app = await fin.Application.start({\n\t     *         uuid: 'app-1',\n\t     *         name: 'myApp',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Application.getParentUuid.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getParentUuid();\n\t     * }\n\t     *\n\t     * getParentUuid().then(parentUuid => console.log(parentUuid)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getParentUuid() {\n\t        return this.wire.sendAction('get-parent-application', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Retrieves current application's shortcut configuration.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function getShortcuts() {\n\t     *     const app = await fin.Application.wrap({ uuid: 'testapp' });\n\t     *     return await app.getShortcuts();\n\t     * }\n\t     * getShortcuts().then(config => console.log(config)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getShortcuts() {\n\t        return this.wire.sendAction('get-shortcuts', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Retrieves current application's views.\n\t     * @experimental\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function getViews() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.getViews();\n\t     * }\n\t     * getViews().then(views => console.log(views)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    async getViews() {\n\t        const { payload } = await this.wire.sendAction('application-get-views', this.identity);\n\t        return payload.data.map((id) => new view_1.View(this.wire, id));\n\t    }\n\t    /**\n\t     * Returns the current zoom level of the application.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function getZoomLevel() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.getZoomLevel();\n\t     * }\n\t     *\n\t     * getZoomLevel().then(zoomLevel => console.log(zoomLevel)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getZoomLevel() {\n\t        return this.wire.sendAction('get-application-zoom-level', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Returns an instance of the main Window of the application\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function getWindow() {\n\t     *     const app = await fin.Application.start({\n\t     *         uuid: 'app-1',\n\t     *         name: 'myApp',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Application.getWindow.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     *\n\t     * getWindow().then(win => {\n\t     *     win.showAt(0, 400);\n\t     *     win.flash();\n\t     * }).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getWindow() {\n\t        this.wire.sendAction('application-get-window', this.identity).catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return Promise.resolve(this.window);\n\t    }\n\t    /**\n\t     * Manually registers a user with the licensing service. The only data sent by this call is userName and appName.\n\t     * @param userName - username to be passed to the RVM.\n\t     * @param appName - app name to be passed to the RVM.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function registerUser() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.registerUser('user', 'myApp');\n\t     * }\n\t     *\n\t     * registerUser().then(() => console.log('Successfully registered the user')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    registerUser(userName, appName) {\n\t        return this.wire.sendAction('register-user', { userName, appName, ...this.identity }).then(() => undefined);\n\t    }\n\t    /**\n\t     * Removes the application’s icon from the tray.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function removeTrayIcon() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.removeTrayIcon();\n\t     * }\n\t     *\n\t     * removeTrayIcon().then(() => console.log('Removed the tray icon.')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    removeTrayIcon() {\n\t        return this.wire.sendAction('remove-tray-icon', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Restarts the application.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function restartApp() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.restart();\n\t     * }\n\t     * restartApp().then(() => console.log('Application restarted')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    restart() {\n\t        return this.wire.sendAction('restart-application', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * DEPRECATED method to run the application.\n\t     * Needed when starting application via {@link Application.create}, but NOT needed when starting via {@link Application.start}.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function run() {\n\t     *     const app = await fin.Application.create({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Application.run.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     await app.run();\n\t     * }\n\t     * run().then(() => console.log('Application is running')).catch(err => console.log(err));\n\t     * ```\n\t     *\n\t     * @ignore\n\t     */\n\t    run() {\n\t        console.warn('Deprecation Warning: Application.run is deprecated Please use fin.Application.start');\n\t        this.wire.sendAction('application-run', this.identity).catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return this._run();\n\t    }\n\t    _run(opts = {}) {\n\t        return this.wire\n\t            .sendAction('run-application', {\n\t            manifestUrl: this._manifestUrl,\n\t            opts,\n\t            ...this.identity\n\t        })\n\t            .then(() => undefined);\n\t    }\n\t    /**\n\t     * Instructs the RVM to schedule one restart of the application.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function scheduleRestart() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.scheduleRestart();\n\t     * }\n\t     *\n\t     * scheduleRestart().then(() => console.log('Application is scheduled to restart')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    scheduleRestart() {\n\t        return this.wire.sendAction('relaunch-on-close', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Sends a message to the RVM to upload the application's logs. On success,\n\t     * an object containing logId is returned.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function sendLog() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.sendApplicationLog();\n\t     * }\n\t     *\n\t     * sendLog().then(info => console.log(info.logId)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    async sendApplicationLog() {\n\t        const { payload } = await this.wire.sendAction('send-application-log', this.identity);\n\t        return payload.data;\n\t    }\n\t    /**\n\t     * Sets or removes a custom JumpList for the application. Only applicable in Windows OS.\n\t     * If categories is null the previously set custom JumpList (if any) will be replaced by the standard JumpList for the app (managed by Windows).\n\t     *\n\t     * Note: If the \"name\" property is omitted it defaults to \"tasks\".\n\t     * @param jumpListCategories An array of JumpList Categories to populate. If null, remove any existing JumpList configuration and set to Windows default.\n\t     *\n\t     *\n\t     * @remarks If categories is null the previously set custom JumpList (if any) will be replaced by the standard JumpList for the app (managed by Windows).\n\t     *\n\t     * The bottommost item in the jumplist will always be an item pointing to the current app. Its name is taken from the manifest's\n\t     * **` shortcut.name `** and uses **` shortcut.company `** as a fallback. Clicking that item will launch the app from its current manifest.\n\t     *\n\t     * Note: If the \"name\" property is omitted it defaults to \"tasks\".\n\t     *\n\t     * Note: Window OS caches jumplists icons, therefore an icon change might only be visible after the cache is removed or the\n\t     * uuid or shortcut.name is changed.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     *     const app = fin.Application.getCurrentSync();\n\t     *     const appName = 'My App';\n\t     *     const jumpListConfig = [ // array of JumpList categories\n\t     *         {\n\t     *             // has no name and no type so `type` is assumed to be \"tasks\"\n\t     *             items: [ // array of JumpList items\n\t     *             {\n\t     *                 type: 'task',\n\t     *                 title: `Launch ${appName}`,\n\t     *                 description: `Runs ${appName} with the default configuration`,\n\t     *                 deepLink: 'fins://path.to/app/manifest.json',\n\t     *                 iconPath: 'https://path.to/app/icon.ico',\n\t     *                 iconIndex: 0\n\t     *             },\n\t     *             { type: 'separator' },\n\t     *             {\n\t     *                 type: 'task',\n\t     *                 title: `Restore ${appName}`,\n\t     *                 description: 'Restore to last configuration',\n\t     *                 deepLink: 'fins://path.to/app/manifest.json?$$use-last-configuration=true',\n\t     *                 iconPath: 'https://path.to/app/icon.ico',\n\t     *                 iconIndex: 0\n\t     *             },\n\t     *             ]\n\t     *         },\n\t     *         {\n\t     *             name: 'Tools',\n\t     *             items: [ // array of JumpList items\n\t     *             {\n\t     *                 type: 'task',\n\t     *                 title: 'Tool A',\n\t     *                 description: 'Runs Tool A',\n\t     *                 deepLink: 'fins://path.to/tool-a/manifest.json',\n\t     *                 iconPath: 'https://path.to/tool-a/icon.ico',\n\t     *                 iconIndex: 0\n\t     *             },\n\t     *             {\n\t     *                 type: 'task',\n\t     *                 title: 'Tool B',\n\t     *                 description: 'Runs Tool B',\n\t     *                 deepLink: 'fins://path.to/tool-b/manifest.json',\n\t     *                 iconPath: 'https://path.to/tool-b/icon.ico',\n\t     *                 iconIndex: 0\n\t     *             }]\n\t     *         }\n\t     *     ];\n\t     *\n\t     *     app.setJumpList(jumpListConfig).then(() => console.log('JumpList applied')).catch(e => console.log(`JumpList failed to apply: ${e.toString()}`));\n\t     * ```\n\t     *\n\t     * To handle deeplink args:\n\t     * ```js\n\t     *     function handleUseLastConfiguration() {\n\t     *         // this handler is called when the app is being launched\n\t     *         app.on('run-requested', event => {\n\t     *             if(event.userAppConfigArgs['use-last-configuration']) {\n\t     *                 // your logic here\n\t     *             }\n\t     *         });\n\t     *         // this handler is called when the app was already running when the launch was requested\n\t     *         fin.desktop.main(function(args) {\n\t     *             if(args && args['use-last-configuration']) {\n\t     *                 // your logic here\n\t     *             }\n\t     *         });\n\t     *     }\n\t     * ```\n\t     */\n\t    async setJumpList(jumpListCategories) {\n\t        await this.wire.sendAction('set-jump-list', { config: jumpListCategories, ...this.identity });\n\t    }\n\t    /**\n\t     * Adds a customizable icon in the system tray.  To listen for a click on the icon use the `tray-icon-clicked` event.\n\t     * @param icon Image URL or base64 encoded string to be used as the icon\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * const imageUrl = \"http://cdn.openfin.co/assets/testing/icons/circled-digit-one.png\";\n\t     * const base64EncodedImage = \"iVBORw0KGgoAAAANSUhEUgAAAAgAAAAIAQMAAAD+wSzIAAAABlBMVEX\\\n\t     * ///+/v7+jQ3Y5AAAADklEQVQI12P4AIX8EAgALgAD/aNpbtEAAAAASUVORK5CYII\";\n\t     * const dataURL = \"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DH\\\n\t     * xgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg==\";\n\t     *\n\t     * async function setTrayIcon(icon) {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.setTrayIcon(icon);\n\t     * }\n\t     *\n\t     * // use image url to set tray icon\n\t     * setTrayIcon(imageUrl).then(() => console.log('Setting tray icon')).catch(err => console.log(err));\n\t     *\n\t     * // use base64 encoded string to set tray icon\n\t     * setTrayIcon(base64EncodedImage).then(() => console.log('Setting tray icon')).catch(err => console.log(err));\n\t     *\n\t     * // use a dataURL to set tray icon\n\t     * setTrayIcon(dataURL).then(() => console.log('Setting tray icon')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    setTrayIcon(icon) {\n\t        return this.wire\n\t            .sendAction('set-tray-icon', {\n\t            enabledIcon: icon,\n\t            ...this.identity\n\t        })\n\t            .then(() => undefined);\n\t    }\n\t    /**\n\t     * Sets new application's shortcut configuration. Windows only.\n\t     * @param config New application's shortcut configuration.\n\t     *\n\t     * @remarks Application has to be launched with a manifest and has to have shortcut configuration (icon url, name, etc.) in its manifest\n\t     * to be able to change shortcut states.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function setShortcuts(config) {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return app.setShortcuts(config);\n\t     * }\n\t     *\n\t     * setShortcuts({\n\t     *     desktop: true,\n\t     *     startMenu: false,\n\t     *     systemStartup: true\n\t     * }).then(() => console.log('Shortcuts are set.')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    setShortcuts(config) {\n\t        return this.wire.sendAction('set-shortcuts', { data: config, ...this.identity }).then(() => undefined);\n\t    }\n\t    /**\n\t     * Sets the query string in all shortcuts for this app. Requires RVM 5.5+.\n\t     * @param queryString The new query string for this app's shortcuts.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * const newQueryArgs = 'arg=true&arg2=false';\n\t     * const app = await fin.Application.getCurrent();\n\t     * try {\n\t     *     await app.setShortcutQueryParams(newQueryArgs);\n\t     * } catch(err) {\n\t     *     console.error(err)\n\t     * }\n\t     * ```\n\t     */\n\t    async setShortcutQueryParams(queryString) {\n\t        await this.wire.sendAction('set-shortcut-query-args', { data: queryString, ...this.identity });\n\t    }\n\t    /**\n\t     * Sets the zoom level of the application. The original size is 0 and each increment above or below represents zooming 20%\n\t     * larger or smaller to default limits of 300% and 50% of original size, respectively.\n\t     * @param level The zoom level\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function setZoomLevel(number) {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.setZoomLevel(number);\n\t     * }\n\t     *\n\t     * setZoomLevel(5).then(() => console.log('Setting a  zoom level')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    setZoomLevel(level) {\n\t        return this.wire.sendAction('set-application-zoom-level', { level, ...this.identity }).then(() => undefined);\n\t    }\n\t    /**\n\t     * Sets a username to correlate with App Log Management.\n\t     * @param username Username to correlate with App's Log.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function setAppLogUser() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.setAppLogUsername('username');\n\t     * }\n\t     *\n\t     * setAppLogUser().then(() => console.log('Success')).catch(err => console.log(err));\n\t     *\n\t     * ```\n\t     */\n\t    async setAppLogUsername(username) {\n\t        await this.wire.sendAction('set-app-log-username', { data: username, ...this.identity });\n\t    }\n\t    /**\n\t     * Retrieves information about the system tray. If the system tray is not set, it will throw an error message.\n\t     * @remarks The only information currently returned is the position and dimensions.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function getTrayIconInfo() {\n\t     *     const app = await fin.Application.wrap({ uuid: 'testapp' });\n\t     *     return await app.getTrayIconInfo();\n\t     * }\n\t     * getTrayIconInfo().then(info => console.log(info)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getTrayIconInfo() {\n\t        return this.wire.sendAction('get-tray-icon-info', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Checks if the application has an associated tray icon.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * const app = await fin.Application.wrap({ uuid: 'testapp' });\n\t     * const hasTrayIcon = await app.hasTrayIcon();\n\t     * console.log(hasTrayIcon);\n\t     * ```\n\t     */\n\t    hasTrayIcon() {\n\t        return this.wire.sendAction('has-tray-icon', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Closes the application by terminating its process.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function terminateApp() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.terminate();\n\t     * }\n\t     * terminateApp().then(() => console.log('Application terminated')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    terminate() {\n\t        return this.wire.sendAction('terminate-application', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Waits for a hanging application. This method can be called in response to an application\n\t     * \"not-responding\" to allow the application to continue and to generate another \"not-responding\"\n\t     * message after a certain period of time.\n\t     *\n\t     * @ignore\n\t     */\n\t    wait() {\n\t        return this.wire.sendAction('wait-for-hung-application', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Retrieves information about the application.\n\t     *\n\t     * @remarks If the application was not launched from a manifest, the call will return the closest parent application `manifest`\n\t     * and `manifestUrl`.  `initialOptions` shows the parameters used when launched programmatically, or the `startup_app` options\n\t     * if launched from manifest. The `parentUuid` will be the uuid of the immediate parent (if applicable).\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function getInfo() {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return await app.getInfo();\n\t     * }\n\t     *\n\t     * getInfo().then(info => console.log(info)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getInfo() {\n\t        return this.wire.sendAction('get-info', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Retrieves all process information for entities (windows and views) associated with an application.\n\t     *\n\t     * @example\n\t     * ```js\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     const processInfo = await app.getProcessInfo();\n\t     * ```\n\t     * @experimental\n\t     */\n\t    async getProcessInfo() {\n\t        const { payload: { data } } = await this.wire.sendAction('application-get-process-info', this.identity);\n\t        return data;\n\t    }\n\t    /**\n\t     * Sets file auto download location. It's only allowed in the same application.\n\t     *\n\t     * Note: This method is restricted by default and must be enabled via\n\t     * <a href=\"https://developers.openfin.co/docs/api-security\">API security settings</a>.\n\t     * @param downloadLocation file auto download location\n\t     *\n\t     * @throws if setting file auto download location on different applications.\n\t     * @example\n\t     *\n\t     * ```js\n\t     * const downloadLocation = 'C:\\\\dev\\\\temp';\n\t     * const app = await fin.Application.getCurrent();\n\t     * try {\n\t     *     await app.setFileDownloadLocation(downloadLocation);\n\t     *     console.log('File download location is set');\n\t     * } catch(err) {\n\t     *     console.error(err)\n\t     * }\n\t     * ```\n\t     */\n\t    async setFileDownloadLocation(downloadLocation) {\n\t        const { name } = this.wire.me;\n\t        const entityIdentity = { uuid: this.identity.uuid, name };\n\t        await this.wire.sendAction('set-file-download-location', { ...entityIdentity, downloadLocation });\n\t    }\n\t    /**\n\t     * Gets file auto download location. It's only allowed in the same application. If file auto download location is not set, it will return the default location.\n\t     *\n\t     * Note: This method is restricted by default and must be enabled via\n\t     * <a href=\"https://developers.openfin.co/docs/api-security\">API security settings</a>.\n\t     *\n\t     * @throws if getting file auto download location on different applications.\n\t     * @example\n\t     *\n\t     * ```js\n\t     * const app = await fin.Application.getCurrent();\n\t     * const fileDownloadDir =  await app.getFileDownloadLocation();\n\t     * ```\n\t     */\n\t    async getFileDownloadLocation() {\n\t        const { payload: { data } } = await this.wire.sendAction('get-file-download-location', this.identity);\n\t        return data;\n\t    }\n\t    /**\n\t     * Shows a menu on the tray icon. Use with tray-icon-clicked event.\n\t     * @param options\n\t     * @typeParam Data User-defined shape for data returned upon menu item click. Should be a\n\t     * [union](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#union-types)\n\t     * of all possible data shapes for the entire menu, and the click handler should process\n\t     * these with a \"reducer\" pattern.\n\t     * @throws if the application has no tray icon set\n\t     * @throws if the system tray is currently hidden\n\t     * @example\n\t     *\n\t     * ```js\n\t     * const iconUrl = 'http://cdn.openfin.co/assets/testing/icons/circled-digit-one.png';\n\t     * const app = fin.Application.getCurrentSync();\n\t     *\n\t     * await app.setTrayIcon(iconUrl);\n\t     *\n\t     * const template = [\n\t     *  {\n\t     *    label: 'Menu Item 1',\n\t     *    data: 'hello from item 1'\n\t     *  },\n\t     *  { type: 'separator' },\n\t     *  {\n\t     *    label: 'Menu Item 2',\n\t     *    type: 'checkbox',\n\t     *    checked: true,\n\t     *    data: 'The user clicked the checkbox'\n\t     *  },\n\t     *  {\n\t     *    label: 'see more',\n\t     *    enabled: false,\n\t     *    submenu: [\n\t     *      { label: 'submenu 1', data: 'hello from submenu' }\n\t     *    ]\n\t     *  }\n\t     * ];\n\t     *\n\t     * app.addListener('tray-icon-clicked', (event) => {\n\t     *   // right-click\n\t     *   if (event.button === 2) {\n\t     *     app.showTrayIconPopupMenu({ template }).then(r => {\n\t     *       if (r.result === 'closed') {\n\t     *         console.log('nothing happened');\n\t     *       } else {\n\t     *         console.log(r.data);\n\t     *       }\n\t     *     });\n\t     *   }\n\t     * });\n\t     * ```\n\t     */\n\t    async showTrayIconPopupMenu(options) {\n\t        const { name } = this.wire.me;\n\t        const entityIdentity = { uuid: this.identity.uuid, name };\n\t        const { payload } = await this.wire.sendAction('show-tray-icon-popup-menu', { ...entityIdentity, options });\n\t        return payload.data;\n\t    }\n\t    /**\n\t     * Closes the tray icon menu.\n\t     *\n\t     * @throws if the application has no tray icon set\n\t     * @example\n\t     *\n\t     * ```js\n\t     * const app = fin.Application.getCurrentSync();\n\t     *\n\t     * await app.closeTrayIconPopupMenu();\n\t     * ```\n\t     */\n\t    async closeTrayIconPopupMenu() {\n\t        const { name } = this.wire.me;\n\t        const entityIdentity = { uuid: this.identity.uuid, name };\n\t        await this.wire.sendAction('close-tray-icon-popup-menu', { ...entityIdentity });\n\t    }\n\t}\n\tInstance$6.Application = Application;\n\treturn Instance$6;\n}\n\nvar hasRequiredFactory$2;\n\nfunction requireFactory$2 () {\n\tif (hasRequiredFactory$2) return Factory$7;\n\thasRequiredFactory$2 = 1;\n\tObject.defineProperty(Factory$7, \"__esModule\", { value: true });\n\tFactory$7.ApplicationModule = void 0;\n\tconst base_1 = base;\n\tconst validate_1 = validate;\n\tconst Instance_1 = requireInstance$1();\n\t/**\n\t * Static namespace for OpenFin API methods that interact with the {@link Application} class, available under `fin.Application`.\n\t */\n\tclass ApplicationModule extends base_1.Base {\n\t    /**\n\t     * Asynchronously returns an API handle for the given Application identity.\n\t     *\n\t     * @remarks Wrapping an Application identity that does not yet exist will *not* throw an error, and instead\n\t     * returns a stub object that cannot yet perform rendering tasks. This can be useful for plumbing eventing\n\t     * for an Application throughout its entire lifecycle.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * fin.Application.wrap({ uuid: 'testapp' })\n\t     * .then(app => app.isRunning())\n\t     * .then(running => console.log('Application is running: ' + running))\n\t     * .catch(err => console.log(err));\n\t     * ```\n\t     *\n\t     */\n\t    async wrap(identity) {\n\t        this.wire.sendAction('wrap-application').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const errorMsg = (0, validate_1.validateIdentity)(identity);\n\t        if (errorMsg) {\n\t            throw new Error(errorMsg);\n\t        }\n\t        return new Instance_1.Application(this.wire, identity);\n\t    }\n\t    /**\n\t     * Synchronously returns an API handle for the given Application identity.\n\t     *\n\t     * @remarks Wrapping an Application identity that does not yet exist will *not* throw an error, and instead\n\t     * returns a stub object that cannot yet perform rendering tasks. This can be useful for plumbing eventing\n\t     * for an Aplication throughout its entire lifecycle.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * const app = fin.Application.wrapSync({ uuid: 'testapp' });\n\t     * await app.close();\n\t     * ```\n\t     *\n\t     */\n\t    wrapSync(identity) {\n\t        this.wire.sendAction('wrap-application-sync').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const errorMsg = (0, validate_1.validateIdentity)(identity);\n\t        if (errorMsg) {\n\t            throw new Error(errorMsg);\n\t        }\n\t        return new Instance_1.Application(this.wire, identity);\n\t    }\n\t    async _create(appOptions) {\n\t        // set defaults:\n\t        if (appOptions.waitForPageLoad === undefined) {\n\t            appOptions.waitForPageLoad = false;\n\t        }\n\t        if (appOptions.autoShow === undefined && appOptions.isPlatformController === undefined) {\n\t            appOptions.autoShow = true;\n\t        }\n\t        await this.wire.sendAction('create-application', appOptions);\n\t        return this.wrap({ uuid: appOptions.uuid });\n\t    }\n\t    /**\n\t     * DEPRECATED method to create a new Application. Use {@link Application.ApplicationModule.start Application.start} instead.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function createApp() {\n\t     *     const app = await fin.Application.create({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-3',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Application.create.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     await app.run();\n\t     * }\n\t     *\n\t     * createApp().then(() => console.log('Application is created')).catch(err => console.log(err));\n\t     * ```\n\t     *\n\t     * @ignore\n\t     */\n\t    create(appOptions) {\n\t        console.warn('Deprecation Warning: fin.Application.create is deprecated. Please use fin.Application.start');\n\t        this.wire.sendAction('application-create').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return this._create(appOptions);\n\t    }\n\t    /**\n\t     * Creates and starts a new Application.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function start() {\n\t     *     return fin.Application.start({\n\t     *         name: 'app-1',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Application.start.html',\n\t     *         autoShow: true\n\t     *     });\n\t     * }\n\t     * start().then(() => console.log('Application is running')).catch(err => console.log(err));\n\t     * ```\n\t     *\n\t     */\n\t    async start(appOptions) {\n\t        this.wire.sendAction('start-application').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const app = await this._create(appOptions);\n\t        await this.wire.sendAction('run-application', { uuid: appOptions.uuid });\n\t        return app;\n\t    }\n\t    /**\n\t     * Asynchronously starts a batch of applications given an array of application identifiers and manifestUrls.\n\t     * Returns once the RVM is finished attempting to launch the applications.\n\t     * @param opts - Parameters that the RVM will use.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     *\n\t     * const applicationInfoArray = [\n\t     *     {\n\t     *         \"uuid\": 'App-1',\n\t     *         \"manifestUrl\": 'http://localhost:5555/app1.json',\n\t     *     },\n\t     *     {\n\t     *         \"uuid\": 'App-2',\n\t     *         \"manifestUrl\": 'http://localhost:5555/app2.json',\n\t     *     },\n\t     *     {\n\t     *         \"uuid\": 'App-3',\n\t     *         \"manifestUrl\": 'http://localhost:5555/app3.json',\n\t     *     }\n\t     * ]\n\t     *\n\t     * fin.Application.startManyManifests(applicationInfoArray)\n\t     *     .then(() => {\n\t     *         console.log('RVM has finished launching the application list.');\n\t     *     })\n\t     *     .catch((err) => {\n\t     *         console.log(err);\n\t     *     })\n\t     * ```\n\t     *\n\t     * @experimental\n\t     */\n\t    async startManyManifests(applications, opts) {\n\t        return this.wire.sendAction('run-applications', { applications, opts }).then(() => undefined);\n\t    }\n\t    /**\n\t     * Asynchronously returns an Application object that represents the current application\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function isCurrentAppRunning () {\n\t     *     const app = await fin.Application.getCurrent();\n\t     *     return app.isRunning();\n\t     * }\n\t     *\n\t     * isCurrentAppRunning().then(running => {\n\t     *     console.log(`Current app is running: ${running}`);\n\t     * }).catch(err => {\n\t     *     console.error(err);\n\t     * });\n\t     *\n\t     * ```\n\t     */\n\t    getCurrent() {\n\t        this.wire.sendAction('get-current-application').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return this.wrap({ uuid: this.wire.me.uuid });\n\t    }\n\t    /**\n\t     * Synchronously returns an Application object that represents the current application\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * async function isCurrentAppRunning () {\n\t     *     const app = fin.Application.getCurrentSync();\n\t     *     return app.isRunning();\n\t     * }\n\t     *\n\t     * isCurrentAppRunning().then(running => {\n\t     *     console.log(`Current app is running: ${running}`);\n\t     * }).catch(err => {\n\t     *     console.error(err);\n\t     * });\n\t     *\n\t     * ```\n\t     */\n\t    getCurrentSync() {\n\t        this.wire.sendAction('get-current-application-sync').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return this.wrapSync({ uuid: this.wire.me.uuid });\n\t    }\n\t    /**\n\t     * Retrieves application's manifest and returns a running instance of the application.\n\t     * @param manifestUrl - The URL of app's manifest.\n\t     * @param opts - Parameters that the RVM will use.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * fin.Application.startFromManifest('http://localhost:5555/app.json').then(app => console.log('App is running')).catch(err => console.log(err));\n\t     *\n\t     * // For a local manifest file:\n\t     * fin.Application.startFromManifest('file:///C:/somefolder/app.json').then(app => console.log('App is running')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    async startFromManifest(manifestUrl, opts) {\n\t        this.wire.sendAction('application-start-from-manifest').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const app = await this._createFromManifest(manifestUrl);\n\t        // @ts-expect-error using private method without warning.\n\t        await app._run(opts); // eslint-disable-line no-underscore-dangle\n\t        return app;\n\t    }\n\t    /**\n\t     * @deprecated Use {@link Application.ApplicationModule.startFromManifest Application.startFromManifest} instead.\n\t     * Retrieves application's manifest and returns a wrapped application.\n\t     * @param manifestUrl - The URL of app's manifest.\n\t     * @param callback - called if the method succeeds.\n\t     * @param errorCallback - called if the method fails. The reason for failure is passed as an argument.\n\t     *\n\t     * @example\n\t     *\n\t     * ```js\n\t     * fin.Application.createFromManifest('http://localhost:5555/app.json').then(app => console.log(app)).catch(err => console.log(err));\n\t     * ```\n\t     * @ignore\n\t     */\n\t    createFromManifest(manifestUrl) {\n\t        console.warn('Deprecation Warning: fin.Application.createFromManifest is deprecated. Please use fin.Application.startFromManifest');\n\t        this.wire.sendAction('application-create-from-manifest').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return this._createFromManifest(manifestUrl);\n\t    }\n\t    _createFromManifest(manifestUrl) {\n\t        return this.wire\n\t            .sendAction('get-application-manifest', { manifestUrl })\n\t            .then(({ payload }) => {\n\t            const uuid = payload.data.platform ? payload.data.platform.uuid : payload.data.startup_app.uuid;\n\t            return this.wrap({ uuid });\n\t        })\n\t            .then((app) => {\n\t            app._manifestUrl = manifestUrl; // eslint-disable-line no-underscore-dangle\n\t            return app;\n\t        });\n\t    }\n\t}\n\tFactory$7.ApplicationModule = ApplicationModule;\n\treturn Factory$7;\n}\n\nvar hasRequiredApplication;\n\nfunction requireApplication () {\n\tif (hasRequiredApplication) return application;\n\thasRequiredApplication = 1;\n\t(function (exports) {\n\t\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t\t    if (k2 === undefined) k2 = k;\n\t\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t\t    }\n\t\t    Object.defineProperty(o, k2, desc);\n\t\t}) : (function(o, m, k, k2) {\n\t\t    if (k2 === undefined) k2 = k;\n\t\t    o[k2] = m[k];\n\t\t}));\n\t\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t\t};\n\t\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t\t/**\n\t\t * Entry points for the OpenFin `Application` API (`fin.Application`).\n\t\t *\n\t\t * * {@link ApplicationModule} contains static members of the `Application` API, accessible through `fin.Application`.\n\t\t * * {@link Application} describes an instance of an OpenFin Application, e.g. as returned by `fin.Application.getCurrent`.\n\t\t *\n\t\t * These are separate code entities, and are documented separately.  In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/32.114.76.10/index.html),\n\t\t * both of these were documented on the same page.\n\t\t *\n\t\t * @packageDocumentation\n\t\t */\n\t\t__exportStar(requireFactory$2(), exports);\n\t\t__exportStar(requireInstance$1(), exports); \n\t} (application));\n\treturn application;\n}\n\nvar promisifySubscription$1 = {};\n\nObject.defineProperty(promisifySubscription$1, \"__esModule\", { value: true });\npromisifySubscription$1.promisifySubscription = void 0;\nconst promisifySubscription = async (emitter, eventName, predicate = () => true, timeout) => {\n    let resolve;\n    let reject;\n    let timer;\n    const valuePromise = new Promise((y, n) => {\n        resolve = y;\n        reject = n;\n    });\n    const listener = (e) => {\n        if (predicate(e)) {\n            clearTimeout(timer);\n            resolve(e);\n        }\n    };\n    await emitter.on(eventName, listener);\n    if (timeout) {\n        timer = setTimeout(() => reject(new Error('event timed out')), timeout);\n    }\n    valuePromise.finally(() => {\n        emitter.removeListener(eventName, listener).catch(() => null);\n    });\n    return {\n        getValue: () => valuePromise\n    };\n};\npromisifySubscription$1.promisifySubscription = promisifySubscription;\n\nvar hasRequiredInstance;\n\nfunction requireInstance () {\n\tif (hasRequiredInstance) return Instance$7;\n\thasRequiredInstance = 1;\n\tObject.defineProperty(Instance$7, \"__esModule\", { value: true });\n\tInstance$7._Window = void 0;\n\t/* eslint-disable import/prefer-default-export */\n\t/* eslint-disable @typescript-eslint/no-unused-vars */\n\t/* eslint-disable no-console */\n\t/* eslint-disable @typescript-eslint/no-non-null-assertion */\n\tconst application_1 = requireApplication();\n\tconst main_1 = main;\n\tconst view_1 = requireView();\n\tconst warnings_1 = warnings;\n\tconst promisifySubscription_1 = promisifySubscription$1;\n\t/**\n\t * A basic window that wraps a native HTML window. Provides more fine-grained\n\t * control over the window state such as the ability to minimize, maximize, restore, etc.\n\t * By default a window does not show upon instantiation; instead the window's show() method\n\t * must be invoked manually. The new window appears in the same process as the parent window.\n\t * It has the ability to listen for {@link OpenFin.WindowEvents window specific events}.\n\t */\n\t// The window.Window name is taken\n\tclass _Window extends main_1.WebContents {\n\t    /**\n\t     * @internal\n\t     */\n\t    constructor(wire, identity) {\n\t        super(wire, identity, 'window');\n\t    }\n\t    async createWindow(options) {\n\t        this.wire.sendAction('window-create-window', this.identity).catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const CONSTRUCTOR_CB_TOPIC = 'fire-constructor-callback';\n\t        const responseSubscription = await (0, promisifySubscription_1.promisifySubscription)(this, CONSTRUCTOR_CB_TOPIC);\n\t        // set defaults:\n\t        if (options.waitForPageLoad === undefined) {\n\t            options.waitForPageLoad = false;\n\t        }\n\t        if (options.autoShow === undefined) {\n\t            options.autoShow = true;\n\t        }\n\t        (0, warnings_1.handleDeprecatedWarnings)(options);\n\t        const windowCreation = this.wire.environment.createChildContent({ entityType: 'window', options });\n\t        const [response] = await Promise.all([responseSubscription.getValue(), windowCreation]);\n\t        let cbPayload;\n\t        const { success } = response;\n\t        const responseData = response.data;\n\t        const { message } = responseData;\n\t        if (success) {\n\t            cbPayload = {\n\t                httpResponseCode: responseData.httpResponseCode,\n\t                apiInjected: responseData.apiInjected\n\t            };\n\t        }\n\t        else {\n\t            cbPayload = {\n\t                message: responseData.message,\n\t                networkErrorCode: responseData.networkErrorCode,\n\t                stack: responseData.stack\n\t            };\n\t        }\n\t        const pageResolve = {\n\t            message,\n\t            cbPayload,\n\t            success\n\t        };\n\t        try {\n\t            // this is to enforce a 5.0 contract that the child's main function\n\t            // will not fire before the parent's success callback on creation.\n\t            // if the child window is not accessible (CORS) this contract does\n\t            // not hold.\n\t            const webWindow = this.getWebWindow();\n\t            webWindow.fin.__internal_.openerSuccessCBCalled();\n\t        }\n\t        catch (e) {\n\t            // common for main windows, we do not want to expose this error. here just to have a debug target.\n\t            // console.error(e);\n\t        }\n\t        if (pageResolve.success) {\n\t            return this;\n\t        }\n\t        return Promise.reject(pageResolve);\n\t    }\n\t    /**\n\t     * Retrieves an array of frame info objects representing the main frame and any\n\t     * iframes that are currently on the page.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function getAllFrames() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getAllFrames.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.getAllFrames();\n\t     * }\n\t     *\n\t     * getAllFrames().then(framesInfo => console.log(framesInfo)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getAllFrames() {\n\t        return this.wire.sendAction('get-all-frames', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Gets the current bounds (top, bottom, right, left, width, height) of the window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function getBounds() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-3',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getBounds.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.getBounds();\n\t     * }\n\t     *\n\t     * getBounds().then(bounds => console.log(bounds)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getBounds() {\n\t        return this.wire\n\t            .sendAction('get-window-bounds', this.identity)\n\t            .then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Centers the window on its current screen.\n\t     *\n\t     * @remarks Does not have an effect on minimized or maximized windows.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function centerWindow() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.center.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.center();\n\t     * }\n\t     *\n\t     * centerWindow().then(() => console.log('Window centered')).catch(err => console.log(err));\n\t     * ```\n\t     *\n\t     */\n\t    center() {\n\t        return this.wire.sendAction('center-window', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Removes focus from the window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function blurWindow() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.blur.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.blur();\n\t     * }\n\t     *\n\t     * blurWindow().then(() => console.log('Blured Window')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    blur() {\n\t        return this.wire.sendAction('blur-window', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Brings the window to the front of the window stack.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function BringWindowToFront() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.bringToFront.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.bringToFront();\n\t     * }\n\t     *\n\t     * BringWindowToFront().then(() => console.log('Window is in the front')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    bringToFront() {\n\t        return this.wire.sendAction('bring-window-to-front', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Performs the specified window transitions.\n\t     * @param transitions - Describes the animations to perform. See the tutorial.\n\t     * @param options - Options for the animation. See the tutorial.\n\t     *\n\t     * @example\n\t     * ```\n\t     * async function animateWindow() {\n\t     *     const transitions = {\n\t     *         opacity: {\n\t     *             opacity: 0.7,\n\t     *             duration: 500\n\t     *         },\n\t     *         position: {\n\t     *             top: 100,\n\t     *             left: 100,\n\t     *             duration: 500,\n\t     *             relative: true\n\t     *         }\n\t     *     };\n\t     *     const options = {\n\t     *         interrupt: true,\n\t     *         tween: 'ease-in'\n\t     *     };\n\t     *\n\t     *     const win = await fin.Window.getCurrent();\n\t     *     return win.animate(transitions, options);\n\t     * }\n\t     *\n\t     * animateWindow()\n\t     *     .then(() => console.log('Animation done'))\n\t     *     .catch(err => console.error(err));\n\t     * ```\n\t     */\n\t    animate(transitions, options) {\n\t        return this.wire\n\t            .sendAction('animate-window', {\n\t            transitions,\n\t            options,\n\t            ...this.identity\n\t        })\n\t            .then(() => undefined);\n\t    }\n\t    /**\n\t     * Hides the window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function hideWindow() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.hide.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.hide();\n\t     * }\n\t     *\n\t     * hideWindow().then(() => console.log('Window is hidden')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    hide() {\n\t        return this.wire.sendAction('hide-window', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * closes the window application\n\t     * @param force Close will be prevented from closing when force is false and\n\t     *  ‘close-requested’ has been subscribed to for application’s main window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function closeWindow() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-3',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.close.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.close();\n\t     * }\n\t     *\n\t     * closeWindow().then(() => console.log('Window closed')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    close(force = false) {\n\t        return this.wire.sendAction('close-window', { force, ...this.identity }).then(() => {\n\t            Object.setPrototypeOf(this, null);\n\t            return undefined;\n\t        });\n\t    }\n\t    focusedWebViewWasChanged() {\n\t        return this.wire.sendAction('focused-webview-changed', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Returns the native OS level Id.\n\t     *\n\t     * @remarks In Windows, it will return the Windows [handle](https://docs.microsoft.com/en-us/windows/desktop/WinProg/windows-data-types#HWND).\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function getWindowNativeId() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-3',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getNativeId.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.getNativeId();\n\t     * }\n\t     *\n\t     * getWindowNativeId().then(nativeId => console.log(nativeId)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getNativeId() {\n\t        return this.wire.sendAction('get-window-native-id', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Retrieves window's attached views.\n\t     * @experimental\n\t     *\n\t     * @example\n\t     * ```js\n\t     * const win = fin.Window.getCurrentSync();\n\t     *\n\t     * win.getCurrentViews()\n\t     *   .then(views => console.log(views))\n\t     *   .catch(console.error);\n\t     * ```\n\t     */\n\t    async getCurrentViews() {\n\t        const { payload } = await this.wire.sendAction('window-get-views', this.identity);\n\t        return payload.data.map((id) => new view_1.View(this.wire, id));\n\t    }\n\t    /**\n\t     * @deprecated Use {@link Window._Window.disableUserMovement} instead.\n\t     */\n\t    disableFrame() {\n\t        console.warn('Function is deprecated; use disableUserMovement instead.');\n\t        return this.wire.sendAction('disable-window-frame', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Prevents a user from changing a window's size/position when using the window's frame.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function disableUserMovement() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-3',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.disableFrame.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.disableUserMovement();\n\t     * }\n\t     *\n\t     * disableUserMovement().then(() => console.log('Window is disabled')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    disableUserMovement() {\n\t        return this.wire.sendAction('disable-window-frame', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * @deprecated Use {@link Window._Window.enableUserMovement} instead.\n\t     */\n\t    enableFrame() {\n\t        console.warn('Function is deprecated; use enableUserMovement instead.');\n\t        return this.wire.sendAction('enable-window-frame', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Re-enables user changes to a window's size/position when using the window's frame.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function enableUserMovement() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-3',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.enableFrame.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.enableUserMovement();\n\t     * }\n\t     *\n\t     * enableUserMovement().then(() => console.log('Window is enabled')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    enableUserMovement() {\n\t        return this.wire.sendAction('enable-window-frame', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Flashes the window’s frame and taskbar icon until stopFlashing is called or until a focus event is fired.\n\t     *\n\t     * @remarks On macOS flash only works on inactive windows.\n\t     * @example\n\t     * ```js\n\t     * async function windowFlash() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.flash.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.flash();\n\t     * }\n\t     *\n\t     * windowFlash().then(() => console.log('Window flashing')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    flash() {\n\t        return this.wire.sendAction('flash-window', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Stops the taskbar icon from flashing.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function stopWindowFlashing() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.stopFlashing.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.stopFlashing();\n\t     * }\n\t     *\n\t     * stopWindowFlashing().then(() => console.log('Application window flashing')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    stopFlashing() {\n\t        return this.wire.sendAction('stop-flash-window', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Gets an information object for the window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function getInfo() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getInfo.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.getInfo();\n\t     * }\n\t     *\n\t     * getInfo().then(info => console.log(info)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getInfo() {\n\t        return this.wire.sendAction('get-window-info', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Retrieves the window's Layout\n\t     *\n\t     * @example\n\t     * ```js\n\t     *     //get the current window\n\t     *     const window = await fin.Window.getCurrent();\n\t     *\n\t     *     //get the layout for the window\n\t     *     const layout = await window.getLayout();\n\t     * ```\n\t     * @experimental\n\t     */\n\t    async getLayout(layoutIdentity) {\n\t        this.wire.sendAction('window-get-layout', this.identity).catch((e) => {\n\t            // don't expose\n\t        });\n\t        const opts = await this.getOptions();\n\t        if (!opts.layout && !opts.layoutSnapshot) {\n\t            throw new Error('Window does not have a Layout');\n\t        }\n\t        return this.fin.Platform.Layout.wrap(layoutIdentity ?? this.identity);\n\t    }\n\t    /**\n\t     * Gets the current settings of the window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function getWindowOptions() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getOptions.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.getOptions();\n\t     * }\n\t     *\n\t     * getWindowOptions().then(opts => console.log(opts)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getOptions() {\n\t        return this.wire.sendAction('get-window-options', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Gets the parent application.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function getParentApplication() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getParentApplication.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.getParentApplication();\n\t     * }\n\t     *\n\t     * getParentApplication().then(parentApplication => console.log(parentApplication)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getParentApplication() {\n\t        this.wire.sendAction('window-get-parent-application', this.identity).catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return Promise.resolve(new application_1.Application(this.wire, this.identity));\n\t    }\n\t    /**\n\t     * Gets the parent window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function getParentWindow() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getParentWindow.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.getParentWindow();\n\t     * }\n\t     *\n\t     * getParentWindow().then(parentWindow => console.log(parentWindow)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getParentWindow() {\n\t        this.wire.sendAction('window-get-parent-window', this.identity).catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return Promise.resolve(new application_1.Application(this.wire, this.identity)).then((app) => app.getWindow());\n\t    }\n\t    /**\n\t     * ***DEPRECATED - please use Window.capturePage.***\n\t     * Gets a base64 encoded PNG image of the window or just part a of it.\n\t     * @param area The area of the window to be captured.\n\t     * Omitting it will capture the whole visible window.\n\t     *\n\t     * @tutorial Window.capturePage\n\t     */\n\t    async getSnapshot(area) {\n\t        const req = { area, ...this.identity };\n\t        console.warn('Window.getSnapshot has been deprecated, please use Window.capturePage');\n\t        const res = await this.wire.sendAction('get-window-snapshot', req);\n\t        return res.payload.data;\n\t    }\n\t    /**\n\t     * Gets the current state (\"minimized\", \"maximized\", or \"normal\") of the window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function getWindowState() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getState.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.getState();\n\t     * }\n\t     *\n\t     * getWindowState().then(winState => console.log(winState)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    getState() {\n\t        return this.wire.sendAction('get-window-state', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Previously called getNativeWindow.\n\t     * Returns the [Window Object](https://developer.mozilla.org/en-US/docs/Web/API/Window)\n\t     * that represents the web context of the target window. This is the same object that\n\t     * you would get from calling [window.open()](https://developer.mozilla.org/en-US/docs/Web/API/Window/open) in a standard web context.\n\t     * The target window needs to be in the same application as the requesting window\n\t     * as well as comply with [same-origin](https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy) policy requirements.\n\t     *\n\t     * @example\n\t     * Injecting content into an empty window:\n\t     *\n\t     * ```js\n\t     * (async ()=> {\n\t     *     try {\n\t     *         const winName = `child-window-${Date.now()}`;\n\t     *         const win = await fin.Window.create({\n\t     *             name: winName,\n\t     *             url: 'about:blank'\n\t     *         });\n\t     *         win.getWebWindow().document.write('<h1>Hello World</h1>');\n\t     *     } catch (err) {\n\t     *         console.error(err);\n\t     *     }\n\t     * })();\n\t     * ```\n\t     *\n\t     * Cloning DOM elements from the parent window (in this example we clone an `h3` element from the parent window):\n\t     * ```js\n\t     * (async ()=> {\n\t     *     try {\n\t     *         const currentWindow = await fin.Window.getCurrent();\n\t     *         const parentWindow = await currentWindow.getParentWindow();\n\t     *         const clonedH3 = parentWindow.getWebWindow().document.querySelector('h3').cloneNode(true);\n\t     *         document.body.append(clonedH3);\n\t     *\n\t     *     } catch (err) {\n\t     *         console.error(err);\n\t     *     }\n\t     * })();\n\t     * ```\n\t     *\n\t     * Rendering on a child window via a library (in this example we are using the [lit-html](https://lit-html.polymer-project.org/)\n\t     * template library to render content on a blank child window. You are not going to be able to copy paste this example without\n\t     * configuring the project correctly but this would demonstrate some templating options available):\n\t     * ```js\n\t     * (async ()=> {\n\t     *     try {\n\t     *         const win = await fin.Window.create({\n\t     *             name: `child-window-${Date.now()}`,\n\t     *             url: 'about:blank'\n\t     *         });\n\t     *         const template = html`\n\t     *             <div>\n\t     *                 <span>Click here: </span>\n\t     *                 <button @click=${()=> console.log('Hello World!')}>log to the console</button>\n\t     *             </div>`;\n\t     *         render(template, win.getWebWindow().document.body);\n\t     *\n\t     *     } catch (err) {\n\t     *         console.error(err);\n\t     *     }\n\t     * })();\n\t     * ```\n\t     */\n\t    getWebWindow() {\n\t        this.wire.sendAction('window-get-web-window', this.identity).catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return this.wire.environment.getWebWindow(this.identity);\n\t    }\n\t    /**\n\t     * Determines if the window is a main window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * const wnd = fin.Window.getCurrentSync();\n\t     * const isMainWnd = wnd.isMainWindow();\n\t     * console.log('Is this a main window? ' + isMainWnd);\n\t     * ```\n\t     */\n\t    isMainWindow() {\n\t        this.wire.sendAction('window-is-main-window', this.identity).catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return this.me.uuid === this.me.name;\n\t    }\n\t    /**\n\t     * Determines if the window is currently showing.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function isWindowShowing() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.isShowing.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.isShowing();\n\t     * }\n\t     *\n\t     * isWindowShowing().then(bool => console.log(bool)).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    isShowing() {\n\t        return this.wire.sendAction('is-window-showing', this.identity).then(({ payload }) => payload.data);\n\t    }\n\t    /**\n\t     * Maximizes the window\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function maxWindow() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.maximize.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     const win = await app.getWindow();\n\t     *     return await win.maximize();\n\t     * }\n\t     *\n\t     * maxWindow().then(() => console.log('Maximized window')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    maximize() {\n\t        return this.wire.sendAction('maximize-window', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Minimizes the window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function minWindow() {\n\t     *     const win = await fin.Window.getCurrent();\n\t     *     return await win.minimize();\n\t     * }\n\t     *\n\t     * minWindow().then(() => console.log('Minimized window')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    minimize() {\n\t        return this.wire.sendAction('minimize-window', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Moves the window by a specified amount.\n\t     * @param deltaLeft The change in the left position of the window\n\t     * @param deltaTop The change in the top position of the window\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWin() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.moveBy.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     *\n\t     * async function moveBy(left, top) {\n\t     *     const win = await createWin();\n\t     *     return await win.moveBy(left, top);\n\t     * }\n\t     *\n\t     * moveBy(580, 300).then(() => console.log('Moved')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    moveBy(deltaLeft, deltaTop, positioningOptions) {\n\t        return this.wire\n\t            .sendAction('move-window-by', {\n\t            deltaLeft,\n\t            deltaTop,\n\t            positioningOptions,\n\t            ...this.identity\n\t        })\n\t            .then(() => undefined);\n\t    }\n\t    /**\n\t     * Moves the window to a specified location.\n\t     * @param left The left position of the window\n\t     * @param top The top position of the window\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWin() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.moveTo.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     *\n\t     * async function moveTo(left, top) {\n\t     *     const win = await createWin();\n\t     *     return await win.moveTo(left, top)\n\t     * }\n\t     *\n\t     * moveTo(580, 300).then(() => console.log('Moved')).catch(err => console.log(err))\n\t     * ```\n\t     */\n\t    moveTo(left, top, positioningOptions) {\n\t        return this.wire\n\t            .sendAction('move-window', {\n\t            left,\n\t            top,\n\t            positioningOptions,\n\t            ...this.identity\n\t        })\n\t            .then(() => undefined);\n\t    }\n\t    /**\n\t     * Resizes the window by a specified amount.\n\t     * @param deltaWidth The change in the width of the window\n\t     * @param deltaHeight The change in the height of the window\n\t     * @param anchor Specifies a corner to remain fixed during the resize.\n\t     * Can take the values: \"top-left\", \"top-right\", \"bottom-left\", or \"bottom-right\".\n\t     * If undefined, the default is \"top-left\"\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWin() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.resizeBy.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     *\n\t     * async function resizeBy(left, top, anchor) {\n\t     *     const win = await createWin();\n\t     *     return await win.resizeBy(left, top, anchor)\n\t     * }\n\t     *\n\t     * resizeBy(580, 300, 'top-right').then(() => console.log('Resized')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    resizeBy(deltaWidth, deltaHeight, anchor, positioningOptions) {\n\t        return this.wire\n\t            .sendAction('resize-window-by', {\n\t            deltaWidth: Math.floor(deltaWidth),\n\t            deltaHeight: Math.floor(deltaHeight),\n\t            anchor,\n\t            positioningOptions,\n\t            ...this.identity\n\t        })\n\t            .then(() => undefined);\n\t    }\n\t    /**\n\t     * Resizes the window to the specified dimensions.\n\t     * @param width The change in the width of the window\n\t     * @param height The change in the height of the window\n\t     * @param anchor Specifies a corner to remain fixed during the resize.\n\t     * Can take the values: \"top-left\", \"top-right\", \"bottom-left\", or \"bottom-right\".\n\t     * If undefined, the default is \"top-left\"\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWin() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.resizeTo.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     *\n\t     * async function resizeTo(left, top, anchor) {\n\t     *     const win = await createWin();\n\t     *     return await win.resizeTo(left, top, anchor);\n\t     * }\n\t     *\n\t     * resizeTo(580, 300, 'top-left').then(() => console.log('Resized')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    resizeTo(width, height, anchor, positioningOptions) {\n\t        return this.wire\n\t            .sendAction('resize-window', {\n\t            width: Math.floor(width),\n\t            height: Math.floor(height),\n\t            anchor,\n\t            positioningOptions,\n\t            ...this.identity\n\t        })\n\t            .then(() => undefined);\n\t    }\n\t    /**\n\t     * Restores the window to its normal state (i.e., unminimized, unmaximized).\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWin() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.restore.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     *\n\t     * async function restore() {\n\t     *     const win = await createWin();\n\t     *     return await win.restore();\n\t     * }\n\t     *\n\t     * restore().then(() => console.log('Restored')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    restore() {\n\t        return this.wire.sendAction('restore-window', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Will bring the window to the front of the entire stack and give it focus.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWin() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.setAsForeground.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     *\n\t     * async function setAsForeground() {\n\t     *     const win = await createWin();\n\t     *     return await win.setAsForeground()\n\t     * }\n\t     *\n\t     * setAsForeground().then(() => console.log('In the foreground')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    setAsForeground() {\n\t        return this.wire.sendAction('set-foreground-window', this.identity).then(() => undefined);\n\t    }\n\t    /**\n\t     * Sets the window's size and position.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWin() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.setBounds.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     *\n\t     * async function setBounds(bounds) {\n\t     *     const win = await createWin();\n\t     *     return await win.setBounds(bounds);\n\t     * }\n\t     *\n\t     * setBounds({\n\t     *     height: 100,\n\t     *     width: 200,\n\t     *     top: 400,\n\t     *     left: 400\n\t     * }).then(() => console.log('Bounds set to window')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    setBounds(bounds, positioningOptions) {\n\t        return this.wire\n\t            .sendAction('set-window-bounds', { ...bounds, ...this.identity, positioningOptions })\n\t            .then(() => undefined);\n\t    }\n\t    /**\n\t     * Shows the window if it is hidden.\n\t     * @param force Show will be prevented from showing when force is false and\n\t     *  ‘show-requested’ has been subscribed to for application’s main window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWin() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.show.html',\n\t     *         autoShow: false\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     *\n\t     * async function show() {\n\t     *     const win = await createWin();\n\t     *     return await win.show()\n\t     * }\n\t     *\n\t     * show().then(() => console.log('Showing')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    show(force = false) {\n\t        return this.wire.sendAction('show-window', { force, ...this.identity }).then(() => undefined);\n\t    }\n\t    /**\n\t     * Shows the window if it is hidden at the specified location.\n\t     *\n\t     * @param left The left position of the window in pixels\n\t     * @param top The top position of the window in pixels\n\t     * @param force Show will be prevented from closing when force is false and\n\t     * ‘show-requested’ has been subscribed to for application’s main window\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWin() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.showAt.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     *\n\t     * async function showAt(left, top) {\n\t     *     const win = await createWin();\n\t     *     return await win.showAt(left, top)\n\t     * }\n\t     *\n\t     * showAt(580, 300).then(() => console.log('Showing at')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    showAt(left, top, force = false) {\n\t        return this.wire\n\t            .sendAction('show-at-window', {\n\t            force,\n\t            left: Math.floor(left),\n\t            top: Math.floor(top),\n\t            ...this.identity\n\t        })\n\t            .then(() => undefined);\n\t    }\n\t    /**\n\t     * Shows the Chromium Developer Tools\n\t     *\n\t     * @tutorial Window.showDeveloperTools\n\t     */\n\t    /**\n\t     * Updates the window using the passed options.\n\t     *\n\t     * @remarks Values that are objects are deep-merged, overwriting only the values that are provided.\n\t     * @param options Changes a window's options that were defined upon creation. See tutorial\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function updateOptions() {\n\t     *     const win = await fin.Window.getCurrent();\n\t     *     return win.updateOptions({maxWidth: 100});\n\t     * }\n\t     * updateOptions().then(() => console.log('options is updated')).catch(err => console.error(err));\n\t     * ```\n\t     */\n\t    updateOptions(options) {\n\t        return this.wire.sendAction('update-window-options', { options, ...this.identity }).then(() => undefined);\n\t    }\n\t    /**\n\t     * Provides credentials to authentication requests\n\t     * @param userName userName to provide to the authentication challenge\n\t     * @param password password to provide to the authentication challenge\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.Application.wrap({uuid: 'OpenfinPOC'}).then(app => {\n\t     *     app.on('window-auth-requested', evt => {\n\t     *         let win = fin.Window.wrap({ uuid: evt.uuid, name: evt.name});\n\t     *         win.authenticate('userName', 'P@assw0rd').then(()=> console.log('authenticated')).catch(err => console.log(err));\n\t     *     });\n\t     * });\n\t     * ```\n\t     */\n\t    authenticate(userName, password) {\n\t        return this.wire\n\t            .sendAction('window-authenticate', { userName, password, ...this.identity })\n\t            .then(() => undefined);\n\t    }\n\t    /**\n\t     * Shows a menu on the window.\n\t     *\n\t     * @remarks Returns a promise that resolves when the user has either selected an item or closed the menu. (This may take longer than other apis).\n\t     * Resolves to an object with `{result: 'clicked', data }` where data is the data field on the menu item clicked, or `{result 'closed'}` when the user doesn't select anything.\n\t     * Calling this method will close previously opened menus.\n\t     * @experimental\n\t     * @param options\n\t     * @typeParam Data User-defined shape for data returned upon menu item click.  Should be a\n\t     * [union](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#union-types)\n\t     * of all possible data shapes for the entire menu, and the click handler should process\n\t     * these with a \"reducer\" pattern.\n\t     * @example\n\t     * This could be used to show a drop down menu over views in a platform window:\n\t     * ```js\n\t     * const template = [\n\t     *     {\n\t     *         label: 'Menu Item 1',\n\t     *         data: 'hello from item 1'\n\t     *     },\n\t     *     { type: 'separator' },\n\t     *     {\n\t     *         label: 'Menu Item 2',\n\t     *         type: 'checkbox',\n\t     *         checked: true,\n\t     *         data: 'The user clicked the checkbox'\n\t     *     },\n\t     *     {\n\t     *         label: 'see more',\n\t     *         enabled: false,\n\t     *         submenu: [\n\t     *             { label: 'submenu 1', data: 'hello from submenu' }\n\t     *         ]\n\t     *     }\n\t     * ]\n\t     * fin.me.showPopupMenu({ template }).then(r => {\n\t     *     if (r.result === 'closed') {\n\t     *         console.log('nothing happened');\n\t     *     } else {\n\t     *         console.log(r.data)\n\t     *     }\n\t     * })\n\t     * ```\n\t     *\n\t     * Overriding the built in context menu (note: that this can be done per element or document wide):\n\t     * ```js\n\t     * document.addEventListener('contextmenu', e => {\n\t     *     e.preventDefault();\n\t     *     const template = [\n\t     *         {\n\t     *             label: 'Menu Item 1',\n\t     *             data: 'hello from item 1'\n\t     *         },\n\t     *         { type: 'separator' },\n\t     *         {\n\t     *             label: 'Menu Item 2',\n\t     *             type: 'checkbox',\n\t     *             checked: true,\n\t     *             data: 'The user clicked the checkbox'\n\t     *         },\n\t     *         {\n\t     *             label: 'see more',\n\t     *             enabled: false,\n\t     *             submenu: [\n\t     *                 { label: 'submenu 1', data: 'hello from submenu' }\n\t     *             ]\n\t     *         }\n\t     *     ]\n\t     *     fin.me.showPopupMenu({ template, x: e.x, y: e.y }).then(r => {\n\t     *         if (r.result === 'closed') {\n\t     *             console.log('nothing happened');\n\t     *         } else {\n\t     *             console.log(r.data)\n\t     *         }\n\t     *     })\n\t     * })\n\t     * ```\n\t     */\n\t    async showPopupMenu(options) {\n\t        const { payload } = await this.wire.sendAction('show-popup-menu', { options, ...this.identity });\n\t        return payload.data;\n\t    }\n\t    /**\n\t     * Closes the window's popup menu, if one exists.\n\t     * @experimental\n\t     *\n\t     * @remarks Only one popup menu will ever be showing at a time. Calling `showPopupMenu` will automatically close\n\t     * any existing popup menu.\n\t     *\n\t     *\n\t     * @example\n\t     * This could be used to close a popup menu if the user's mouse leaves an element for example.\n\t     *\n\t     * ```js\n\t     * await fin.me.closePopupMenu();\n\t     * ```\n\t     */\n\t    async closePopupMenu() {\n\t        return this.wire.sendAction('close-popup-menu', { ...this.identity }).then(() => undefined);\n\t    }\n\t    /**\n\t     * Dispatch a result to the caller of `showPopupWindow`.\n\t     *\n\t     * @remarks If this window isn't currently being shown as a popup, this call will silently fail.\n\t     * @param data Serializable data to send to the caller window.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * await fin.me.dispatchPopupResult({\n\t     *     foo: 'bar'\n\t     * });\n\t     * ```\n\t     */\n\t    async dispatchPopupResult(data) {\n\t        this.wire.sendAction('window-dispatch-popup-result', this.identity).catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        await this.wire.sendAction('dispatch-popup-result', { data, ...this.identity });\n\t    }\n\t    /**\n\t     * Prints the contents of the window.\n\t     *\n\t     * @param options Configuration for the print task.\n\t     * @remarks When `silent` is set to `true`, the API will pick the system's default printer if deviceName is empty\n\t     * and the default settings for printing.\n\t     *\n\t     * Use the CSS style `page-break-before: always;` to force print to a new page.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * const win = fin.Window.getCurrentSync();\n\t     *\n\t     * win.print({ silent: false, deviceName: 'system-printer-name' }).then(() => {\n\t     *     console.log('print call has been sent to the system');\n\t     * });\n\t     * ```\n\t     *\n\t     * If a window has embedded views, those views will not print by default.  To print a window's contents including embedded views,\n\t     * use the `content` option:\n\t     *\n\t     * ```js\n\t     * const win = fin.Window.getCurrentSync();\n\t     *\n\t     * // Print embedded views\n\t     * win.print({ content: 'views' });\n\t     *\n\t     * // Print screenshot of current window\n\t     * win.print({ content: 'screenshot' })\n\t     * ```\n\t     *\n\t     * When `content` is set to `views`, the embedded views in the platform window will be concatenated and printed as\n\t     * individual pages.  If `includeSelf` is set to `true`, the platform window itself will be printed as the first\n\t     * page - be aware that this page will *not* include the embedded views - it will only include the contents of\n\t     * the platform window itself (e.g. tab stacks), with blank spaces where the view contents would be embedded.\n\t     *\n\t     * Due to a known issue, view contents that are not visible at the time `print` is called will not appear when\n\t     * printing `contents: views`.  This includes views that are obscured behind other active UI elements.\n\t     *\n\t     * To print the views embedded in their page context, set `content` to `screenshot`.\n\t     */\n\t    async print(options = { content: 'self' }) {\n\t        switch (options.content) {\n\t            case undefined:\n\t            case 'self':\n\t                return super.print(options);\n\t            case 'screenshot':\n\t                return this.wire.sendAction('print-screenshot', this.identity).then(() => undefined);\n\t            case 'views':\n\t                return this.wire.sendAction('print-views', { ...this.identity, options }).then(() => undefined);\n\t            default:\n\t                return undefined;\n\t        }\n\t    }\n\t}\n\tInstance$7._Window = _Window;\n\treturn Instance$7;\n}\n\nvar hasRequiredFactory$1;\n\nfunction requireFactory$1 () {\n\tif (hasRequiredFactory$1) return Factory$8;\n\thasRequiredFactory$1 = 1;\n\tObject.defineProperty(Factory$8, \"__esModule\", { value: true });\n\tFactory$8._WindowModule = void 0;\n\tconst base_1 = base;\n\tconst validate_1 = validate;\n\tconst Instance_1 = requireInstance();\n\t/**\n\t * Static namespace for OpenFin API methods that interact with the {@link _Window} class, available under `fin.Window`.\n\t */\n\tclass _WindowModule extends base_1.Base {\n\t    /**\n\t     * Asynchronously returns an API handle for the given Window identity.\n\t     *\n\t     * @remarks Wrapping a Window identity that does not yet exist will *not* throw an error, and instead\n\t     * returns a stub object that cannot yet perform rendering tasks. This can be useful for plumbing eventing\n\t     * for a Window throughout its entire lifecycle.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWin() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.wrap.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     * createWin().then(() => fin.Window.wrap({ uuid: 'app-1', name: 'myApp' }))\n\t     * .then(win => console.log('wrapped window'))\n\t     * .catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    async wrap(identity) {\n\t        this.wire.sendAction('window-wrap').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const errorMsg = (0, validate_1.validateIdentity)(identity);\n\t        if (errorMsg) {\n\t            throw new Error(errorMsg);\n\t        }\n\t        return new Instance_1._Window(this.wire, identity);\n\t    }\n\t    /**\n\t     * Synchronously returns an API handle for the given Window identity.\n\t     *\n\t     * @remarks Wrapping a Window identity that does not yet exist will *not* throw an error, and instead\n\t     * returns a stub object that cannot yet perform rendering tasks. This can be useful for plumbing eventing\n\t     * for a Window throughout its entire lifecycle.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWin() {\n\t     *     const app = await fin.Application.start({\n\t     *         name: 'myApp',\n\t     *         uuid: 'app-1',\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.wrapSync.html',\n\t     *         autoShow: true\n\t     *     });\n\t     *     return await app.getWindow();\n\t     * }\n\t     * await createWin();\n\t     * let win = fin.Window.wrapSync({ uuid: 'app-1', name: 'myApp' });\n\t     * ```\n\t     */\n\t    wrapSync(identity) {\n\t        this.wire.sendAction('window-wrap-sync').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const errorMsg = (0, validate_1.validateIdentity)(identity);\n\t        if (errorMsg) {\n\t            throw new Error(errorMsg);\n\t        }\n\t        return new Instance_1._Window(this.wire, identity);\n\t    }\n\t    /**\n\t     * Creates a new Window.\n\t     * @param options - Window creation options\n\t     *\n\t     * @example\n\t     * ```js\n\t     * async function createWindow() {\n\t     *     const winOption = {\n\t     *         name:'child',\n\t     *         defaultWidth: 300,\n\t     *         defaultHeight: 300,\n\t     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.create.html',\n\t     *         frame: true,\n\t     *         autoShow: true\n\t     *     };\n\t     *     return await fin.Window.create(winOption);\n\t     * }\n\t     *\n\t     * createWindow().then(() => console.log('Window is created')).catch(err => console.log(err));\n\t     * ```\n\t     */\n\t    create(options) {\n\t        this.wire.sendAction('create-window').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const win = new Instance_1._Window(this.wire, { uuid: this.me.uuid, name: options.name });\n\t        return win.createWindow(options);\n\t    }\n\t    /**\n\t     * Asynchronously returns a Window object that represents the current window\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.Window.getCurrent()\n\t     * .then(wnd => console.log('current window'))\n\t     * .catch(err => console.log(err));\n\t     *\n\t     * ```\n\t     */\n\t    getCurrent() {\n\t        this.wire.sendAction('get-current-window').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        if (!this.wire.me.isWindow) {\n\t            throw new Error('You are not in a Window context');\n\t        }\n\t        const { uuid, name } = this.wire.me;\n\t        return this.wrap({ uuid, name });\n\t    }\n\t    /**\n\t     * Synchronously returns a Window object that represents the current window\n\t     *\n\t     * @example\n\t     * ```js\n\t     * const wnd = fin.Window.getCurrentSync();\n\t     * const info = await wnd.getInfo();\n\t     * console.log(info);\n\t     *\n\t     * ```\n\t     */\n\t    getCurrentSync() {\n\t        this.wire.sendAction('get-current-window-sync').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        if (!this.wire.me.isWindow) {\n\t            throw new Error('You are not in a Window context');\n\t        }\n\t        const { uuid, name } = this.wire.me;\n\t        return this.wrapSync({ uuid, name });\n\t    }\n\t}\n\tFactory$8._WindowModule = _WindowModule;\n\treturn Factory$8;\n}\n\nvar hasRequiredWindow;\n\nfunction requireWindow () {\n\tif (hasRequiredWindow) return window$1;\n\thasRequiredWindow = 1;\n\t(function (exports) {\n\t\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t\t    if (k2 === undefined) k2 = k;\n\t\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t\t    }\n\t\t    Object.defineProperty(o, k2, desc);\n\t\t}) : (function(o, m, k, k2) {\n\t\t    if (k2 === undefined) k2 = k;\n\t\t    o[k2] = m[k];\n\t\t}));\n\t\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t\t};\n\t\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t\t/**\n\t\t * Entry points for the OpenFin `Window` API (`fin.Window`).\n\t\t *\n\t\t * * {@link _WindowModule} contains static members of the `Window` API, accessible through `fin.Window`.\n\t\t * * {@link _Window} describes an instance of an OpenFin Window, e.g. as returned by `fin.Window.getCurrent`.\n\t\t *\n\t\t * These are separate code entities, and are documented separately.  In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/32.114.76.10/index.html),\n\t\t * both of these were documented on the same page.\n\t\t *\n\t\t * Underscore prefixing of OpenFin types that alias DOM entities will be fixed in a future version.\n\t\t *\n\t\t * @packageDocumentation\n\t\t */\n\t\t__exportStar(requireFactory$1(), exports);\n\t\t__exportStar(requireInstance(), exports); \n\t} (window$1));\n\treturn window$1;\n}\n\n/**\n * Entry point for the OpenFin `System` API (`fin.System`).\n *\n * * {@link System} contains static members of the `System` API (available under `fin.System`)\n *\n * @packageDocumentation\n */\nObject.defineProperty(system, \"__esModule\", { value: true });\nsystem.System = void 0;\nconst base_1$i = base;\nconst transport_errors_1$1 = transportErrors;\nconst window_1 = requireWindow();\nconst events_1$6 = require$$0;\n/**\n * An object representing the core of OpenFin Runtime. Allows the developer\n * to perform system-level actions, such as accessing logs, viewing processes,\n * clearing the cache and exiting the runtime as well as listen to {@link OpenFin.SystemEvents system events}.\n *\n */\nclass System extends base_1$i.EmitterBase {\n    /**\n     * @internal\n     */\n    constructor(wire) {\n        super(wire, 'system');\n    }\n    sendExternalProcessRequest(action, options) {\n        return new Promise((resolve, reject) => {\n            const exitEventKey = 'external-process-exited';\n            let processUuid;\n            let exitPayload;\n            let externalProcessExitHandler;\n            let ofWindow;\n            if (typeof options.listener === 'function') {\n                externalProcessExitHandler = (payload) => {\n                    const data = payload || {};\n                    exitPayload = {\n                        topic: 'exited',\n                        uuid: data.processUuid || '',\n                        exitCode: data.exitCode || 0\n                    };\n                    if (processUuid === payload.processUuid) {\n                        options.listener(exitPayload);\n                        ofWindow.removeListener(exitEventKey, externalProcessExitHandler);\n                    }\n                };\n                // window constructor expects the name is not undefined\n                if (!this.wire.me.name) {\n                    this.wire.me.name = this.wire.me.uuid;\n                }\n                ofWindow = new window_1._Window(this.wire, this.wire.me);\n                ofWindow.on(exitEventKey, externalProcessExitHandler);\n            }\n            this.wire\n                .sendAction(action, options)\n                .then(({ payload }) => {\n                processUuid = payload.data.uuid;\n                resolve(payload.data);\n                if (exitPayload && processUuid === exitPayload.uuid) {\n                    options.listener(exitPayload);\n                    ofWindow.removeListener(exitEventKey, externalProcessExitHandler);\n                }\n            })\n                .catch((err) => {\n                if (ofWindow) {\n                    ofWindow.removeListener(exitEventKey, externalProcessExitHandler);\n                }\n                reject(err);\n            });\n        });\n    }\n    /**\n     * Returns the version of the runtime. The version contains the major, minor,\n     * build and revision numbers.\n     *\n     * @example\n     * ```js\n     * fin.System.getVersion().then(v => console.log(v)).catch(err => console.log(err));\n     * ```\n     */\n    getVersion() {\n        return this.wire.sendAction('get-version').then(({ payload }) => payload.data);\n    }\n    /**\n     * Clears cached data containing application resource\n     * files (images, HTML, JavaScript files), cookies, and items stored in the\n     * Local Storage.\n     * @param options - See below for details.\n     *\n     * @remarks For more information on the accepted options, see the following pages:\n     * * cache: browsing data cache for html files and images ([caching](https://developer.mozilla.org/en-US/docs/Web/HTTP/Caching))\n     * * cookies: browser [cookies](https://developer.mozilla.org/en-US/docs/Web/HTTP/Cookies)\n     * * localStorage: browser data that can be used across sessions ([local storage](https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage))\n     * * appcache: html5 [application cache](https://developer.mozilla.org/en-US/docs/Web/HTML/Using_the_application_cache)\n     * @example\n     * ```js\n     * const clearCacheOptions = {\n     *     appcache: true,\n     *     cache: true,\n     *     cookies: true,\n     *     localStorage: true\n     * };\n     * fin.System.clearCache(clearCacheOptions).then(() => console.log('Cache cleared')).catch(err => console.log(err));\n     * ```\n     *\n     */\n    clearCache(options) {\n        return this.wire.sendAction('clear-cache', options).then(() => undefined);\n    }\n    /**\n     * Clears all cached data when OpenFin Runtime exits.\n     *\n     * @example\n     * ```js\n     * fin.System.deleteCacheOnExit().then(() => console.log('Deleted Cache')).catch(err => console.log(err));\n     * ```\n     */\n    deleteCacheOnExit() {\n        return this.wire.sendAction('delete-cache-request').then(() => undefined);\n    }\n    /**\n     * Exits the Runtime.\n     *\n     * @example\n     * ```js\n     * fin.System.exit().then(() => console.log('exit')).catch(err => console.log(err));\n     * ```\n     */\n    exit() {\n        return this.wire.sendAction('exit-desktop').then(() => undefined);\n    }\n    /**\n     * Fetches a JSON manifest using the browser process and returns a Javascript object.\n     * @param manifestUrl The URL of the manifest to fetch.\n     *\n     * @example\n     * ```js\n     * const manifest = await fin.System.fetchManifest('https://www.path-to-manifest.com');\n     * console.log(manifest);\n     * ```\n     */\n    async fetchManifest(manifestUrl) {\n        const { payload: { data } } = await this.wire.sendAction('fetch-manifest', { manifestUrl });\n        return data;\n    }\n    /**\n     * Writes any unwritten cookies data to disk.\n     *\n     * @example\n     * ```js\n     * fin.System.flushCookieStore()\n     *     .then(() => console.log('success'))\n     *     .catch(err => console.error(err));\n     * ```\n     */\n    flushCookieStore() {\n        return this.wire.sendAction('flush-cookie-store').then(() => undefined);\n    }\n    /**\n     * Retrieves an array of data (name, ids, bounds) for all application windows.\n     *\n     * @example\n     * ```js\n     * fin.System.getAllWindows().then(wins => console.log(wins)).catch(err => console.log(err));\n     * ```\n     */\n    getAllWindows() {\n        return this.wire.sendAction('get-all-windows').then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves an array of data for all applications.\n     *\n     * @example\n     * ```js\n     * fin.System.getAllApplications().then(apps => console.log(apps)).catch(err => console.log(err));\n     * ```\n     */\n    getAllApplications() {\n        return this.wire.sendAction('get-all-applications').then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves the command line argument string that started OpenFin Runtime.\n     *\n     * @example\n     * ```js\n     * fin.System.getCommandLineArguments().then(args => console.log(args)).catch(err => console.log(err));\n     * ```\n     */\n    getCommandLineArguments() {\n        return this.wire.sendAction('get-command-line-arguments').then(({ payload }) => payload.data);\n    }\n    /**\n     * Get the current state of the crash reporter.\n     *\n     * @example\n     * ```js\n     * fin.System.getCrashReporterState().then(state => console.log(state)).catch(err => console.log(err));\n     * ```\n     */\n    async getCrashReporterState() {\n        const { payload: { data: { diagnosticMode, isRunning } } } = await this.wire.sendAction('get-crash-reporter-state');\n        console.warn('diagnosticMode property is deprecated. It will be removed in a future version');\n        return {\n            // diagnosticMode will be removed in a future version\n            diagnosticMode,\n            diagnosticsMode: diagnosticMode,\n            isRunning\n        };\n    }\n    /**\n     * Start the crash reporter if not already running.\n     * @param options - configure crash reporter\n     *\n     * @remarks You can optionally specify `diagnosticsMode` to have the logs sent to\n     * OpenFin on runtime close. (NOTE: `diagnosticsMode` will turn on verbose logging and disable the sandbox\n     * for newly launched renderer processes. See https://developers.openfin.co/of-docs/docs/debugging#diagnostics-mode for\n     * more details.)\n     *\n     * @example\n     * ```js\n     * fin.System.startCrashReporter({diagnosticsMode: true}).then(reporter => console.log(reporter)).catch(err => console.log(err));\n     * ```\n     */\n    async startCrashReporter(options) {\n        const opts = options;\n        const newOpts = { ...opts, diagnosticMode: opts.diagnosticsMode || opts.diagnosticMode };\n        const { payload: { data: { diagnosticMode, isRunning } } } = await this.wire.sendAction('start-crash-reporter', newOpts);\n        return {\n            // diagnosticMode will be removed in a future version\n            diagnosticMode,\n            diagnosticsMode: diagnosticMode,\n            isRunning\n        };\n    }\n    /**\n     * Returns a hex encoded hash of the machine id and the currently logged in user name.\n     * This is the recommended way to uniquely identify a user / machine combination.\n     *\n     * @remarks For Windows systems this is a sha256 hash of the machine ID set in the registry key:\n     * `HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Cryptography\\MachineGuid` and `USERNAME`.\n     *\n     * For OSX systems, a native-level call is used to get the machine ID.\n     *\n     * @example\n     * ```js\n     * fin.System.getUniqueUserId().then(id => console.log(id)).catch(err => console.log(err));\n     * ```\n     */\n    getUniqueUserId() {\n        return this.wire.sendAction('get-unique-user-id').then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves a frame info object for the uuid and name passed in\n     * @param uuid - The UUID of the target.\n     * @param name - The name of the target.\n     *\n     * @remarks The possible types are 'window', 'iframe', 'external connection' or 'unknown'.\n     * @example\n     * ```js\n     * const entityUuid = 'OpenfinPOC';\n     * const entityName = '40c74b5d-ed98-40f7-853f-e3d3c2699175';\n     * fin.System.getEntityInfo(entityUuid, entityName).then(info => console.log(info)).catch(err => console.log(err));\n     *\n     * // example info shape\n     * {\n     *     \"uuid\": \"OpenfinPOC\",\n     *     \"name\": \"40c74b5d-ed98-40f7-853f-e3d3c2699175\",\n     *     \"parent\": {\n     *         \"uuid\": \"OpenfinPOC\",\n     *         \"name\": \"OpenfinPOC\"\n     *     },\n     *     \"entityType\": \"iframe\"\n     * }\n     * ```\n     */\n    getEntityInfo(uuid, name) {\n        return this.wire.sendAction('get-entity-info', { uuid, name }).then(({ payload }) => payload.data);\n    }\n    /**\n     * Gets the value of a given environment variable on the computer on which the runtime is installed\n     *\n     * @example\n     * ```js\n     * fin.System.getEnvironmentVariable('HOME').then(env => console.log(env)).catch(err => console.log(err));\n     * ```\n     */\n    getEnvironmentVariable(envName) {\n        return this.wire\n            .sendAction('get-environment-variable', {\n            environmentVariables: envName\n        })\n            .then(({ payload }) => payload.data);\n    }\n    /**\n     * Get currently focused Window.\n     * If a View currently has focus, returns the identity of View's parent Window.\n     * Use {@link Window._Window#getFocusedContent Window.getFocusedContent} to directly access currently focused Window or View.\n     *\n     * @example\n     * ```js\n     * fin.System.getFocusedWindow().then(winInfo => console.log(winInfo)).catch(err => console.log(err));\n     * ```\n     */\n    getFocusedWindow() {\n        return this.wire.sendAction('get-focused-window').then(({ payload }) => payload.data);\n    }\n    /**\n     * Get currently focused content. Returns identity of entity with `entityType`.\n     *\n     * @example\n     * ```js\n     * fin.System.getFocusedContent().then(contentIdentity => console.log(contentIdentity)).catch(err => console.log(err));\n     * ```\n     */\n    getFocusedContent() {\n        return this.wire.sendAction('get-focused-content').then(({ payload }) => payload.data);\n    }\n    /**\n     * Returns information about the given app's certification status\n     *\n     * @example\n     * ```js\n     * const manifestUrl = \"http://localhost:1234/app.json\"\n     * try {\n     *     const certificationInfo = await fin.System.isAppCertified(manifestUrl);\n     * } catch(err) {\n     *     console.error(err)\n     * }\n     * ```\n     */\n    async isAppCertified(manifestUrl) {\n        const { payload: { data: { certifiedInfo } } } = await this.wire.sendAction('is-app-certified', { manifestUrl });\n        return certifiedInfo;\n    }\n    /**\n     * Returns an array of all the installed runtime versions in an object.\n     *\n     * @example\n     * ```js\n     * fin.System.getInstalledRuntimes().then(runtimes => console.log(runtimes)).catch(err => console.log(err));\n     * ```\n     */\n    // incompatible with standalone node process.\n    getInstalledRuntimes() {\n        return this.wire.sendAction('get-installed-runtimes').then(({ payload }) => payload.data.runtimes);\n    }\n    // incompatible with standalone node process.\n    async getInstalledApps() {\n        const { payload: { data: { installedApps } } } = await this.wire.sendAction('get-installed-apps');\n        return installedApps;\n    }\n    /**\n     * Retrieves the contents of the log with the specified filename.\n     * @param options A object that id defined by the GetLogRequestType interface\n     *\n     * @example\n     * ```js\n     * async function getLog() {\n     *     const logs = await fin.System.getLogList();\n     *     return await fin.System.getLog(logs[0]);\n     * }\n     *\n     * getLog().then(log => console.log(log)).catch(err => console.log(err));\n     * ```\n     */\n    getLog(options) {\n        return this.wire.sendAction('view-log', options).then(({ payload }) => payload.data);\n    }\n    /**\n     * Returns a unique identifier (UUID) provided by the machine.\n     *\n     * @example\n     * ```js\n     * fin.System.getMachineId().then(id => console.log(id)).catch(err => console.log(err));\n     * ```\n     */\n    getMachineId() {\n        return this.wire.sendAction('get-machine-id').then(({ payload }) => payload.data);\n    }\n    /**\n     * Returns the minimum (inclusive) logging level that is currently being written to the log.\n     *\n     * @example\n     * ```js\n     * fin.System.getMinLogLevel().then(level => console.log(level)).catch(err => console.log(err));\n     * ```\n     */\n    getMinLogLevel() {\n        return this.wire.sendAction('get-min-log-level').then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves an array containing information for each log file.\n     *\n     * @example\n     * ```js\n     * fin.System.getLogList().then(logList => console.log(logList)).catch(err => console.log(err));\n     * ```\n     */\n    getLogList() {\n        return this.wire.sendAction('list-logs').then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves an object that contains data about the monitor setup of the\n     * computer that the runtime is running on.\n     *\n     * @example\n     * ```js\n     * fin.System.getMonitorInfo().then(monitorInfo => console.log(monitorInfo)).catch(err => console.log(err));\n     * ```\n     */\n    getMonitorInfo() {\n        return this.wire.sendAction('get-monitor-info').then(({ payload }) => payload.data);\n    }\n    /**\n     * Returns the mouse in virtual screen coordinates (left, top).\n     *\n     * @example\n     * ```js\n     * fin.System.getMousePosition().then(mousePosition => console.log(mousePosition)).catch(err => console.log(err));\n     * ```\n     */\n    getMousePosition() {\n        return this.wire.sendAction('get-mouse-position').then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves an array of all of the runtime processes that are currently\n     * running. Each element in the array is an object containing the uuid\n     * and the name of the application to which the process belongs.\n     * @deprecated Please use our new set of process APIs:\n     * {@link Window._Window#getProcessInfo Window.getProcessInfo}\n     * {@link View.View#getProcessInfo View.getProcessInfo}\n     * {@link Application.Application#getProcessInfo Application.getProcessInfo}\n     * {@link System#getAllProcessInfo System.getAllProcessInfo}\n     *\n     * @example\n     * ```js\n     * fin.System.getProcessList().then(ProcessList => console.log(ProcessList)).catch(err => console.log(err));\n     * ```\n     */\n    getProcessList() {\n        // eslint-disable-next-line no-console\n        console.warn('System.getProcessList has been deprecated. Please consider using our new process APIs: Window.getProcessInfo, View.getProcessInfo, Application.getProcessInfo, System.getAllProcessInfo');\n        return this.wire.sendAction('process-snapshot').then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves all process information.\n     *\n     * @remarks This includes the browser process and every process associated to all entities (windows and views).\n     *\n     * @example\n     * ```js\n     * const allProcessInfo = await fin.System.getAllProcessInfo();\n     * ```\n     * @experimental\n     */\n    async getAllProcessInfo() {\n        const { payload: { data } } = await this.wire.sendAction('get-all-process-info', this.identity);\n        return data;\n    }\n    /**\n     * Retrieves the Proxy settings.\n     *\n     * @example\n     * ```js\n     * fin.System.getProxySettings().then(ProxySetting => console.log(ProxySetting)).catch(err => console.log(err));\n     *\n     * //This response has the following shape:\n     * {\n     *     config: {\n     *         proxyAddress: \"proxyAddress\", //the configured Proxy Address\n     *         proxyPort: 0, //the configured Proxy port\n     *         type: \"system\" //Proxy Type\n     *     },\n     *     system: {\n     *         autoConfigUrl: \"\",\n     *         bypass: \"\",\n     *         enabled: false,\n     *         proxy: \"\"\n     *     }\n     * }\n     * ```\n     */\n    getProxySettings() {\n        return this.wire.sendAction('get-proxy-settings').then(({ payload }) => payload.data);\n    }\n    /**\n     * Returns information about the running Runtime in an object.\n     *\n     * @example\n     * ```js\n     * fin.System.getRuntimeInfo().then(RuntimeInfo => console.log(RuntimeInfo)).catch(err => console.log(err));\n     * ```\n     */\n    getRuntimeInfo() {\n        return this.wire.sendAction('get-runtime-info').then(({ payload }) => payload.data);\n    }\n    /**\n     * Returns information about the running RVM in an object.\n     *\n     * @example\n     * ```js\n     * fin.System.getRvmInfo().then(RvmInfo => console.log(RvmInfo)).catch(err => console.log(err));\n     * ```\n     */\n    // incompatible with standalone node process.\n    getRvmInfo() {\n        return this.wire.sendAction('get-rvm-info').then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves general system information. If you need more detailed information about the\n     * OS and the currently logged in user, use `fin.System.getOSInfo()` instead.\n     *\n     * @example\n     * ```js\n     * fin.System.getHostSpecs().then(specs => console.log(specs)).catch(err => console.log(err));\n     * ```\n     */\n    getHostSpecs() {\n        return this.wire.sendAction('get-host-specs').then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves information about the OS and the currently logged in user.\n     *\n     * @example\n     * ```js\n     * fin.System.getOSInfo().then(specs => console.log(specs)).catch(err => console.log(err));\n     * ```\n     */\n    getOSInfo() {\n        return this.wire.sendAction('get-os-info').then(({ payload }) => payload.data);\n    }\n    /**\n     * Runs an executable or batch file. A path to the file must be included in options.\n     * <br> A uuid may be optionally provided. If not provided, OpenFin will create a uuid for the new process.\n     * <br> Note: This method is restricted by default and must be enabled via\n     * <a href=\"https://developers.openfin.co/docs/api-security\">API security settings</a>. Also, this api has an enhanced permission set to make it less dangerous. So application owners can only allow to launch the assets owned by the application, the enabled downloaded files or the restricted executables.\n     * @param options A object that is defined in the ExternalProcessRequestType interface\n     *\n     * @remarks If an unused UUID is provided in options, it will be used. If no UUID is provided, OpenFin will assign one.\n     * This api has an enhanced permission set to make it less dangerous. So application owners can only allow to launch the\n     * assets owned by the application, the enabled downloaded files or the restricted executables.\n     *\n     * **Note:** Since _appAssets_ relies on the RVM, which is missing on MAC_OS, 'alias' is not available. Instead provide\n     * the full path e.g. _/Applications/Calculator.app/Contents/MacOS/Calculator_.\n     *\n     * @example\n     * Basic Example:\n     * ```js\n     * fin.System.launchExternalProcess({\n     *     path: 'notepad',\n     *     arguments: '',\n     *     listener: function (result) {\n     *         console.log('the exit code', result.exitCode);\n     *     }\n     * }).then(processIdentity => {\n     *     console.log(processIdentity);\n     * }).catch(error => {\n     *     console.log(error);\n     * });\n     * ```\n     *\n     * Promise resolution:\n     *\n     * ```js\n     * //This response has the following shape:\n     * {\n     *     uuid: \"FB3E6E36-0976-4C2B-9A09-FB2E54D2F1BB\" // The mapped UUID which identifies the launched process\n     * }\n     * ```\n     *\n     * Listener callback:\n     * ```js\n     * //This response has the following shape:\n     * {\n     *     topic: \"exited\", // Or \"released\" on a call to releaseExternalProcess\n     *     uuid: \"FB3E6E36-0976-4C2B-9A09-FB2E54D2F1BB\", // The mapped UUID which identifies the launched process\n     *     exitCode: 0 // Process exit code\n     * }\n     * ```\n     *\n     * By specifying a lifetime, an external process can live as long the window/application that launched it or\n     * persist after the application exits. The default value is null, which is equivalent to 'persist', meaning\n     * the process lives on after the application exits:\n     *\n     * ```js\n     * fin.System.launchExternalProcess({\n     *     path: 'notepad',\n     *     arguments: '',\n     *     listener: (result) => {\n     *         console.log('the exit code', result.exitCode);\n     *     },\n     *     lifetime: 'window'\n     * }).then(processIdentity => {\n     *     console.log(processIdentity);\n     * }).catch(error => {\n     *     console.log(error);\n     * });\n     * ```\n     *\n     * Note: A process that exits when the window/application exits cannot be released via fin.desktop.System.releaseExternalProcess.\n     *\n     * By specifying a cwd, it will set current working directory when launching an external process:\n     *\n     * ```js\n     * fin.System.launchExternalProcess({\n     *     path: 'cmd.exe',\n     *     cwd: 'c:\\\\temp',\n     *     arguments: '',\n     *     listener: (result) => {\n     *         console.log('the exit code', result.exitCode);\n     *     }\n     * }).then(processIdentity => {\n     *     console.log(processIdentity);\n     * }).catch(error => {\n     *     console.log(error);\n     * });\n     * ```\n     *\n     * Example using an alias from app.json appAssets property:\n     *\n     * ```json\n     * \"appAssets\": [\n     *     {\n     *         \"src\": \"exe.zip\",\n     *         \"alias\": \"myApp\",\n     *         \"version\": \"4.12.8\",\n     *         \"target\": \"myApp.exe\",\n     *         \"args\": \"a b c d\"\n     *     },\n     * ]\n     * ```\n     *\n     * ```js\n     * //  When called, if no arguments are passed then the arguments (if any)\n     * //  are taken from the 'app.json' file, from the  'args' parameter\n     * //  of the 'appAssets' Object with the relevant 'alias'.\n     * fin.System.launchExternalProcess({\n     *     //Additionally note that the executable found in the zip file specified in appAssets\n     *     //will default to the one mentioned by appAssets.target\n     *     //If the the path below refers to a specific path it will override this default\n     *     alias: 'myApp',\n     *     listener: (result) => {\n     *         console.log('the exit code', result.exitCode);\n     *     }\n     * }).then(processIdentity => {\n     *     console.log(processIdentity);\n     * }).catch(error => {\n     *     console.log(error);\n     * });\n     * ```\n     *\n     * Example using an alias but overriding the arguments:\n     *\n     * ```json\n     * \"appAssets\": [\n     *     {\n     *         \"src\": \"exe.zip\",\n     *         \"alias\": \"myApp\",\n     *         \"version\": \"4.12.8\",\n     *         \"target\": \"myApp.exe\",\n     *         \"args\": \"a b c d\"\n     *     },\n     * ]\n     * ```\n     *\n     * ```js\n     * //  If 'arguments' is passed as a parameter it takes precedence\n     * //  over any 'args' set in the 'app.json'.\n     * fin.System.launchExternalProcess({\n     *     alias: 'myApp',\n     *     arguments: 'e f g',\n     *     listener: (result) => {\n     *         console.log('the exit code', result.exitCode);\n     *     }\n     * }).then(processIdentity => {\n     *     console.log(processIdentity);\n     * }).catch(error => {\n     *     console.log(error);\n     * });\n     * ```\n     *\n     * It is now possible to optionally perform any combination of the following certificate checks\n     * against an absolute target via `fin.desktop.System.launchExternalProcess()`:\n     *\n     * ```js\n     * \"certificate\": {\n     *     \"serial\": \"3c a5 ...\",                        // A hex string with or without spaces\n     *     \"subject\": \"O=OpenFin INC., L=New York, ...\", // An internally tokenized and comma delimited string allowing partial or full checks of the subject fields\n     *     \"publickey\": \"3c a5 ...\",                     // A hex string with or without spaces\n     *     \"thumbprint\": \"3c a5 ...\",                    // A hex string with or without spaces\n     *     \"trusted\": true                               // A boolean indicating that the certificate is trusted and not revoked\n     * }\n     * ```\n     *\n     * Providing this information as part of the default configurations for assets in an application's manifest\n     * will be added in a future RVM update:\n     *\n     * ```js\n     * fin.System.launchExternalProcess({\n     *     path: 'C:\\\\Users\\\\ExampleUser\\\\AppData\\\\Local\\\\OpenFin\\\\OpenFinRVM.exe',\n     *     arguments: '--version',\n     *     certificate: {\n     *         trusted: true,\n     *         subject: 'O=OpenFin INC., L=New York, S=NY, C=US',\n     *         thumbprint: '‎3c a5 28 19 83 05 fe 69 88 e6 8f 4b 3a af c5 c5 1b 07 80 5b'\n     *     },\n     *     listener: (result) => {\n     *         console.log('the exit code', result.exitCode);\n     *     }\n     * }).then(processIdentity => {\n     *     console.log(processIdentity);\n     * }).catch(error => {\n     *     console.log(error);\n     * });\n     * ```\n     *\n     * It is possible to launch files that have been downloaded by the user by listening to the window\n     * `file-download-completed` event and using the `fileUuid` provided by the event:\n     *\n     * ```js\n     * const win = fin.Window.getCurrentSync();\n     * win.addListener('file-download-completed', (evt) => {\n     *     if (evt.state === 'completed') {\n     *         fin.System.launchExternalProcess({\n     *             fileUuid: evt.fileUuid,\n     *             arguments: '',\n     *             listener: (result) => {\n     *                 console.log('the exit code', result.exitCode);\n     *             }\n     *         }).then(processIdentity => {\n     *             console.log(processIdentity);\n     *         }).catch(error => {\n     *             console.log(error);\n     *         });\n     *     }\n     * });\n     * ```\n     *\n     * Launching assets specified in the app manifest:\n     *\n     * Sample appAssets section in app.json\n     * ```js\n     *     \"appAssets\": [\n     *         {\n     *             \"src\": \"http://filesamples.com/exe.zip\",\n     *             \"alias\": \"myApp\",\n     *             \"version\": \"4.12.8\",\n     *             \"target\": \"myApp.exe\",\n     *             \"args\": \"a b c d\"\n     *         },\n     *         {\n     *             \"src\": \"http://examples.com/exe.zip\",\n     *             \"alias\": \"myApp2\",\n     *             \"version\": \"5.12.8\",\n     *             \"target\": \"myApp2.exe\",\n     *             \"args\": \"a b c\"\n     *         }\n     *     ]\n     * ```\n     *\n     * This permission allows for launching of all assets specified in the above appAssets section. (\"myApp\" and \"myApp2\"):\n     *\n     * ```js\n     *     \"permissions\": {\n     *        \"System\": {\n     *            \"launchExternalProcess\": {\n     *                 \"enabled\": true,\n     *                 \"assets\": {\n     *                     \"enabled\": true\n     *                 }\n     *             }\n     *        }\n     *     }\n     * ```\n     *\n     * This permission allows for launching of _only_ the \"myApp\" asset in the above appAssets section, as defined in `srcRules`:\n     * ```js\n     *     \"permissions\": {\n     *        \"System\": {\n     *            \"launchExternalProcess\": {\n     *                 \"enabled\": true,\n     *                 \"assets\": {\n     *                     \"enabled\": true\n     *                     \"srcRules\": [\n     *                         {\n     *                             \"match\": [\n     *                                 \"*://filesamples.com/*\"\n     *                             ],\n     *                             \"behavior\": \"allow\"\n     *                         },\n     *                         {\n     *                             \"match\": [\n     *                                 \"<all_urls>\"\n     *                             ],\n     *                             \"behavior\": \"block\"\n     *                         }\n     *                     ]\n     *                 }\n     *             }\n     *        }\n     *     }\n     * ```\n     *\n     * Launching downloaded files:\n     * ```js\n     *     \"permissions\": {\n     *        \"System\": {\n     *            \"launchExternalProcess\": {\n     *                 \"enabled\": true,\n     *                 \"downloads\": {\n     *                     \"enabled\": true\n     *                 }\n     *             }\n     *        }\n     *     }\n     * ```\n     *\n     * This permission allows to launch all the executables:\n     * ```js\n     *     \"permissions\": {\n     *        \"System\": {\n     *            \"launchExternalProcess\": {\n     *                 \"enabled\": true,\n     *                 \"executables\": {\n     *                     \"enabled\": true\n     *                 }\n     *             }\n     *        }\n     *     }\n     * ```\n     *\n     *\n     * This permission only allows launching of executables whose file paths match the corresponding `pathRules`:\n     * ```js\n     *     \"permissions\": {\n     *        \"System\": {\n     *            \"launchExternalProcess\": {\n     *                 \"enabled\": true,\n     *                 \"executables\": {\n     *                     \"enabled\": true\n     *                     \"pathRules\": [\n     *                         {\n     *                             \"match\": [\n     *                                 \"/Windows/System32/*.exe\"\n     *                             ],\n     *                             \"behavior\": \"allow\"\n     *                         },\n     *                         {\n     *                             \"match\": [\n     *                                 \"*.exe\"\n     *                             ],\n     *                             \"behavior\": \"block\"\n     *                         }\n     *                     ]\n     *                 }\n     *             }\n     *        }\n     *     }\n     * ```\n     */\n    launchExternalProcess(options) {\n        return this.sendExternalProcessRequest('launch-external-process', options);\n    }\n    /**\n     * Monitors a running process. A pid for the process must be included in options.\n     * <br> A uuid may be optionally provided. If not provided, OpenFin will create a uuid for the new process.\n     *\n     * @remarks If an unused uuid is provided in options, it will be used. If no uuid is provided, OpefinFin will assign a uuid.\n     * @example\n     * ```js\n     * fin.System.monitorExternalProcess({\n     *     pid: 10208,\n     *     uuid: 'my-external-process', // optional\n     *     listener: function (result) {\n     *         console.log('the exit code', result.exitCode);\n     *     }\n     * }).then(processIdentity => console.log(processIdentity)).catch(err => console.log(err));\n     * ```\n     */\n    monitorExternalProcess(options) {\n        return this.sendExternalProcessRequest('monitor-external-process', options);\n    }\n    /**\n     * Writes the passed message into both the log file and the console.\n     * @param level The log level for the entry. Can be either \"info\", \"warning\" or \"error\"\n     * @param message The log message text\n     *\n     * @example\n     * ```js\n     * fin.System.log(\"info\", \"An example log message\").then(() => console.log('Log info message')).catch(err => console.log(err));\n     * ```\n     */\n    log(level, message) {\n        return this.wire.sendAction('write-to-log', { level, message }).then(() => undefined);\n    }\n    /**\n     * Opens the passed URL in the default web browser.\n     *\n     * @remarks It only supports http(s) and fin(s) protocols by default.\n     * In order to use other custom protocols, they have to be enabled via\n     * [API security settings](https://developers.openfin.co/docs/api-security).\n     * File protocol and file path are not supported.\n     * @param url The URL to open\n     *\n     * @example\n     * ```js\n     * fin.System.openUrlWithBrowser('https://cdn.openfin.co/docs/javascript/stable/tutorial-System.openUrlWithBrowser.html')\n     * .then(() => console.log('Opened URL'))\n     * .catch(err => console.log(err));\n     * ```\n     *\n     * Example of permission definition to enable non-default protocols:\n     *\n     * Note: permission definition should be specified in an app manifest file if there is no DOS settings.\n     * Otherwise it has to be specified in both DOS and app manifest files.\n     *\n     * ```js\n     *     \"permissions\": {\n     *        \"System\": {\n     *            \"openUrlWithBrowser\": {\n     *                 \"enabled\": true,\n     *                 \"protocols\": [ \"msteams\", \"slack\"]\n     *             }\n     *        }\n     *     }\n     * ```\n     */\n    openUrlWithBrowser(url) {\n        return this.wire.sendAction('open-url-with-browser', { url }).then(() => undefined);\n    }\n    /**\n     * Creates a new registry entry under the HKCU root Windows registry key if the given custom protocol name doesn't exist or\n     * overwrites the existing registry entry if the given custom protocol name already exists.\n     *\n     * Note: This method is restricted by default and must be enabled via\n     * {@link https://developers.openfin.co/docs/api-security API security settings}. It requires RVM 12 or higher version.\n     *\n     *\n     * @remarks These protocols are reserved and cannot be registered:\n     * - fin\n     * - fins\n     * - openfin\n     * - URI Schemes registered with {@link https://en.wikipedia.org/wiki/List_of_URI_schemes#Official_IANA-registered_schemes IANA}\n     *\n     * @throws if a given custom protocol failed to be registered.\n     * @throws if a manifest URL contains the '%1' string.\n     * @throws if a manifest URL contains a query string parameter which name equals to the Protocol Launch Request Parameter Name.\n     * @throws if the full length of the command string that is to be written to the registry exceeds 2048 bytes.\n     *\n     * @example\n     * ```js\n     * fin.System.registerCustomProtocol({protocolName:'protocol1'}).then(console.log).catch(console.error);\n     * ```\n     */\n    async registerCustomProtocol(options) {\n        if (typeof options !== 'object') {\n            throw new Error('Must provide an object with a `protocolName` property having a string value.');\n        }\n        await this.wire.sendAction('register-custom-protocol', options);\n    }\n    /**\n     * Removes the registry entry for a given custom protocol.\n     *\n     * Note: This method is restricted by default and must be enabled via\n     * {@link https://developers.openfin.co/docs/api-security API security settings}. It requires RVM 12 or higher version.\n     *\n     *\n     * @remarks These protocols are reserved and cannot be unregistered:\n     * - fin\n     * - fins\n     * - openfin\n     * - URI Schemes registered with {@link https://en.wikipedia.org/wiki/List_of_URI_schemes#Official_IANA-registered_schemes IANA}\n     *\n     * @throws if a protocol entry failed to be removed in registry.\n     *\n     * @example\n     * ```js\n     * await fin.System.unregisterCustomProtocol('protocol1');\n     * ```\n     */\n    async unregisterCustomProtocol(protocolName) {\n        await this.wire.sendAction('unregister-custom-protocol', { protocolName });\n    }\n    /**\n     * Retrieves the registration state for a given custom protocol.\n     *\n     * Note: This method is restricted by default and must be enabled via\n     * {@link https://developers.openfin.co/docs/api-security API security settings}. It requires RVM 12 or higher version.\n     *\n     * @remarks These protocols are reserved and cannot get states for them:\n     * - fin\n     * - fins\n     * - openfin\n     * - URI Schemes registered with {@link https://en.wikipedia.org/wiki/List_of_URI_schemes#Official_IANA-registered_schemes IANA}\n     *\n     *\n     * @example\n     * ```js\n     * const protocolState = await fin.System.getCustomProtocolState('protocol1');\n     */\n    async getCustomProtocolState(protocolName) {\n        return this.wire.sendAction('get-custom-protocol-state', { protocolName }).then(({ payload }) => payload.data);\n    }\n    /**\n     * Removes the process entry for the passed UUID obtained from a prior call\n     * of fin.System.launchExternalProcess().\n     * @param uuid The UUID for a process obtained from a prior call to fin.desktop.System.launchExternalProcess()\n     *\n     * @example\n     * ```js\n     * fin.System.launchExternalProcess({\n     *     path: \"notepad\",\n     *     listener: function (result) {\n     *         console.log(\"The exit code\", result.exitCode);\n     *     }\n     * })\n     * .then(identity => fin.System.releaseExternalProcess(identity.uuid))\n     * .then(() => console.log('Process has been unmapped!'))\n     * .catch(err => console.log(err));\n     * ```\n     */\n    releaseExternalProcess(uuid) {\n        return this.wire.sendAction('release-external-process', { uuid }).then(() => undefined);\n    }\n    /**\n     * Shows the Chromium Developer Tools for the specified window\n     * @param identity This is a object that is defined by the Identity interface\n     *\n     * @tutorial System.showDeveloperTools\n     */\n    showDeveloperTools(identity) {\n        return this.wire.sendAction('show-developer-tools', identity).then(() => undefined);\n    }\n    /**\n     * Attempt to close an external process. The process will be terminated if it\n     * has not closed after the elapsed timeout in milliseconds.\n     *\n     * Note: This method is restricted by default and must be enabled via\n     * <a href=\"https://developers.openfin.co/docs/api-security\">API security settings</a>.\n     * @param options A object defined in the TerminateExternalRequestType interface\n     *\n     * @example\n     * ```js\n     * fin.System.launchExternalProcess({\n     *     path: \"notepad\",\n     *     listener: function (result) {\n     *         console.log(\"The exit code\", result.exitCode);\n     *     }\n     * })\n     * .then(identity => fin.System.terminateExternalProcess({uuid: identity.uuid, timeout:2000, killTree: false}))\n     * .then(() => console.log('Terminate the process'))\n     * .catch(err => console.log(err));\n     * ```\n     */\n    terminateExternalProcess(options) {\n        return this.wire.sendAction('terminate-external-process', options).then(() => undefined);\n    }\n    /**\n     * Update the OpenFin Runtime Proxy settings.\n     * @param options A config object defined in the ProxyConfig interface\n     *\n     * @example\n     * ```js\n     * fin.System.updateProxySettings({proxyAddress:'127.0.0.1', proxyPort:8080, type:'http'})\n     * .then(() => console.log('Update proxy successfully'))\n     * .catch(err => console.error(err));\n     * ```\n     */\n    updateProxySettings(options) {\n        return this.wire.sendAction('update-proxy', options).then(() => undefined);\n    }\n    /**\n     * Downloads the given application asset.\n     *\n     * Note: This method is restricted by default and must be enabled via\n     * <a href=\"https://developers.openfin.co/docs/api-security\">API security settings</a>.\n     * @param appAsset App asset object\n     *\n     * @example\n     * ```js\n     * async function downloadAsset() {\n     *     const appAsset = {\n     *         src: `${ location.origin }/assets.zip`,\n     *         alias: 'dirApp',\n     *         version: '1.23.24',\n     *         target: 'assets/run.bat'\n     *     };\n     *\n     *     return fin.System.downloadAsset(appAsset, (progress => {\n     *     //Print progress as we download the asset.\n     *         const downloadedPercent = Math.floor((progress.downloadedBytes / progress.totalBytes) * 100);\n     *         console.log(`Downloaded ${downloadedPercent}%`);\n     *     }));\n     * }\n     *\n     * downloadAsset()\n     * .then(() => console.log('Success'))\n     * .catch(err => console.error(err));\n     *\n     * ```\n     */\n    // incompatible with standalone node process.\n    async downloadAsset(appAsset, progressListener) {\n        // eslint-disable-next-line @typescript-eslint/explicit-function-return-type, @typescript-eslint/no-empty-function\n        const noop = () => { };\n        let resolve = noop;\n        let reject = noop;\n        const downloadCompletePromise = new Promise((y, n) => {\n            resolve = y;\n            reject = n;\n        });\n        // node.js environment not supported\n        if (this.wire.environment.type !== 'openfin') {\n            throw new transport_errors_1$1.NotSupportedError('downloadAsset only supported in an OpenFin Render process');\n        }\n        const callSite = transport_errors_1$1.RuntimeError.getCallSite();\n        const downloadId = this.wire.environment.getNextMessageId().toString();\n        const dlProgressKey = `asset-download-progress-${downloadId}`;\n        const dlErrorKey = `asset-download-error-${downloadId}`;\n        const dlCompleteKey = `asset-download-complete-${downloadId}`;\n        const dlProgress = (progress) => {\n            const p = {\n                downloadedBytes: progress.downloadedBytes,\n                totalBytes: progress.totalBytes\n            };\n            progressListener(p);\n        };\n        const cleanListeners = () => {\n            // TODO: fix internal types\n            // @ts-expect-error\n            this.removeListener(dlProgressKey, dlProgress);\n        };\n        const dlError = (payload) => {\n            cleanListeners();\n            const { reason, err: error } = payload;\n            reject(new transport_errors_1$1.RuntimeError({ reason, error }, callSite));\n        };\n        const dlComplete = () => {\n            cleanListeners();\n            resolve();\n        };\n        await Promise.all([\n            // TODO: fix internal types\n            // @ts-expect-error\n            this.on(dlProgressKey, dlProgress),\n            // TODO: fix internal types\n            // @ts-expect-error\n            this.once(dlErrorKey, dlError),\n            // TODO: fix internal types\n            // @ts-expect-error\n            this.once(dlCompleteKey, dlComplete)\n        ]);\n        const downloadOptions = Object.assign(appAsset, { downloadId });\n        await this.wire.sendAction('download-asset', downloadOptions).catch((err) => {\n            cleanListeners();\n            throw err;\n        });\n        return downloadCompletePromise;\n    }\n    /**\n     * Downloads a version of the runtime.\n     * @param options - Download options.\n     * @param progressListener - called as the runtime is downloaded with progress information.\n     *\n     * @remarks Only supported in an OpenFin Render process.\n     *\n     * @example\n     * ```js\n     * var downloadOptions = {\n     *     //Specific version number required, if given a release channel the call will produce an error.\n     *     version: '9.61.30.1'\n     * };\n     *\n     * function onProgress(progress) {\n     *     console.log(`${Math.floor((progress.downloadedBytes / progress.totalBytes) * 100)}%`);\n     * }\n     *\n     * fin.System.downloadRuntime(downloadOptions, onProgress).then(() => {\n     *     console.log('Download complete');\n     * }).catch(err =>    {\n     *     console.log(`Download Failed, we could retry: ${err.message}`);\n     *     console.log(err);\n     * });\n     * ```\n     */\n    downloadRuntime(options, progressListener) {\n        const callsites = transport_errors_1$1.RuntimeError.getCallSite();\n        return new Promise((resolve, reject) => {\n            // node.js environment not supported\n            if (this.wire.environment.type !== 'openfin') {\n                reject(new transport_errors_1$1.NotSupportedError('downloadRuntime only supported in an OpenFin Render process'));\n                return;\n            }\n            const downloadId = this.wire.environment.getNextMessageId().toString();\n            const dlProgressKey = `runtime-download-progress-${downloadId}`;\n            const dlErrorKey = `runtime-download-error-${downloadId}`;\n            const dlCompleteKey = `runtime-download-complete-${downloadId}`;\n            const dlProgress = (progress) => {\n                const p = {\n                    downloadedBytes: progress.downloadedBytes,\n                    totalBytes: progress.totalBytes\n                };\n                progressListener(p);\n            };\n            const cleanListeners = () => {\n                // TODO: fix internal types\n                // @ts-expect-error\n                this.removeListener(dlProgressKey, dlProgress);\n            };\n            const dlError = (payload) => {\n                cleanListeners();\n                const { reason, err: error } = payload;\n                reject(new transport_errors_1$1.RuntimeError({ reason, error }, callsites));\n            };\n            const dlComplete = () => {\n                cleanListeners();\n                resolve();\n            };\n            // TODO: fix internal types\n            // @ts-expect-error\n            this.on(dlProgressKey, dlProgress);\n            // TODO: fix internal types\n            // @ts-expect-error\n            this.once(dlErrorKey, dlError);\n            // TODO: fix internal types\n            // @ts-expect-error\n            this.once(dlCompleteKey, dlComplete);\n            const downloadOptions = Object.assign(options, { downloadId });\n            this.wire.sendAction('download-runtime', downloadOptions).catch((err) => {\n                cleanListeners();\n                reject(err);\n            });\n        });\n    }\n    /**\n     * Download preload scripts from given URLs\n     * @param scripts - URLs of preload scripts.\n     *\n     * @example\n     * ```js\n     * const scripts = [\n     *     { url: 'http://.../preload.js' },\n     *     { url: 'http://.../preload2.js' }\n     * ];\n     *\n     * fin.System.downloadPreloadScripts(scripts).then(results => {\n     *     results.forEach(({url, success, error}) => {\n     *         console.log(`URL: ${url}`);\n     *         console.log(`Success: ${success}`);\n     *         if (error) {\n     *             console.log(`Error: ${error}`);\n     *         }\n     *     });\n     * });\n     * ```\n     */\n    downloadPreloadScripts(scripts) {\n        return this.wire.sendAction('download-preload-scripts', { scripts }).then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves an array of data (name, ids, bounds) for all application windows.\n     *\n     * @example\n     * ```js\n     * fin.System.getAllExternalApplications()\n     * .then(externalApps => console.log('Total external apps: ' + externalApps.length))\n     * .catch(err => console.log(err));\n     * ```\n     */\n    getAllExternalApplications() {\n        return this.wire.sendAction('get-all-external-applications').then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves app asset information.\n     * @param options\n     *\n     * @example\n     * ```js\n     * fin.System.getAppAssetInfo({alias:'procexp'}).then(assetInfo => console.log(assetInfo)).catch(err => console.log(err));\n     * ```\n     */\n    getAppAssetInfo(options) {\n        return this.wire.sendAction('get-app-asset-info', options).then(({ payload }) => payload.data);\n    }\n    /**\n     * Get additional info of cookies.\n     *\n     * @example\n     * ```js\n     * fin.System.getCookies({name: 'myCookie'}).then(cookies => console.log(cookies)).catch(err => console.log(err));\n     * ```\n     */\n    getCookies(options) {\n        const url = this.wire.environment.getUrl();\n        const newOptions = Object.assign(options, { url });\n        return this.wire.sendAction('get-cookies', newOptions).then(({ payload }) => payload.data);\n    }\n    /**\n     * Set the minimum log level above which logs will be written to the OpenFin log\n     * @param The minimum level (inclusive) above which all calls to log will be written\n     *\n     * @example\n     * ```js\n     * fin.System.setMinLogLevel(\"verbose\").then(() => console.log(\"log level is set to verbose\")).catch(err => console.log(err));\n     * ```\n     */\n    setMinLogLevel(level) {\n        return this.wire.sendAction('set-min-log-level', { level }).then(() => undefined);\n    }\n    /**\n     * Retrieves the UUID of the computer on which the runtime is installed\n     * @param uuid The uuid of the running application\n     *\n     * @example\n     * ```js\n     * fin.System.resolveUuid('OpenfinPOC').then(entity => console.log(entity)).catch(err => console.log(err));\n     * ```\n     */\n    resolveUuid(uuid) {\n        return this.wire\n            .sendAction('resolve-uuid', {\n            entityKey: uuid\n        })\n            .then(({ payload }) => payload.data);\n    }\n    /**\n     * Retrieves an array of data for all external applications\n     * @param requestingIdentity This object is described in the Identity typedef\n     * @param data Any data type to pass to the method\n     *\n     * @ignore\n     */\n    executeOnRemote(requestingIdentity, data) {\n        data.requestingIdentity = requestingIdentity;\n        return this.wire.ferryAction(data);\n    }\n    /**\n     * Reads the specifed value from the registry.\n     * @remarks This method is restricted by default and must be enabled via\n     * [API security settings](https://developers.openfin.co/docs/api-security).\n     * @param rootKey - The registry root key.\n     * @param subkey - The registry key.\n     * @param value - The registry value name.\n     *\n     * @example\n     * ```js\n     * fin.System.readRegistryValue(\"HKEY_LOCAL_MACHINE\", \"HARDWARE\\\\DESCRIPTION\\\\System\", \"BootArchitecture\").then(val => console.log(val)).catch(err => console.log(err));\n     * ```\n     *\n     * See {@link https://msdn.microsoft.com/en-us/library/windows/desktop/ms681382(v=vs.85).aspx here} for Window's error code definitions.\n     *\n     * Example payloads of different registry types:\n     *\n     * See list of types {@link https://msdn.microsoft.com/en-us/library/windows/desktop/ms724884(v=vs.85).aspx here}.\n     *\n     * ```js\n     * // REG_DWORD\n     * {\n     *     data: 1,\n     *     rootKey: \"HKEY_LOCAL_MACHINE\",\n     *     subkey: \"Foo\\Bar\",\n     *     type: \"REG_DWORD\",\n     *     value: \"Baz\"\n     * }\n     *\n     * // REG_QWORD\n     * {\n     *     data: 13108146671334112,\n     *     rootKey: \"HKEY_LOCAL_MACHINE\",\n     *     subkey: \"Foo\\Bar\",\n     *     type: \"REG_QWORD\",\n     *     value: \"Baz\"\n     * }\n     *\n     * // REG_SZ\n     * {\n     *     data: \"FooBarBaz\",\n     *     rootKey: \"HKEY_LOCAL_MACHINE\",\n     *     subkey: \"Foo\\Bar\",\n     *     type: \"REG_SZ\",\n     *     value: \"Baz\"\n     * }\n     *\n     * // REG_EXPAND_SZ\n     * {\n     *     data: \"C:\\User\\JohnDoe\\AppData\\Local\",\n     *     rootKey: \"HKEY_CURRENT_USER\",\n     *     subkey: \"Foo\\Bar\",\n     *     type: \"REG_EXPAND_SZ\",\n     *     value: \"Baz\"\n     * }\n     *\n     * // REG_MULTI_SZ\n     * {\n     *     data: [\n     *         \"Foo\",\n     *         \"Bar\",\n     *         \"Baz\"\n     *     ],\n     *     rootKey: \"HKEY_CURRENT_USER\",\n     *     subkey: \"Foo\\Bar\",\n     *     type: \"REG_MULTI_SZ\",\n     *     value: \"Baz\"\n     * }\n     *\n     * // REG_BINARY\n     * {\n     *     data: {\n     *         data: [\n     *             255,\n     *             255,\n     *             0,\n     *             43,\n     *             55,\n     *             0,\n     *             0,\n     *             255,\n     *             255\n     *         ],\n     *         type: \"Buffer\"\n     *     },\n     *     rootKey: \"HKEY_CURRENT_USER\",\n     *     subkey: \"Foo\\Bar\",\n     *     type: \"REG_BINARY\",\n     *     value: \"Baz\"\n     * }\n     * ```\n     */\n    readRegistryValue(rootKey, subkey, value) {\n        return this.wire\n            .sendAction('read-registry-value', {\n            rootKey,\n            subkey,\n            value\n        })\n            .then(({ payload }) => payload.data);\n    }\n    /**\n     * This function call will register a unique id and produce a token.\n     * The token can be used to broker an external connection.\n     * @param uuid - A UUID for the remote connection.\n     *\n     * @example\n     * ```js\n     * fin.System.registerExternalConnection(\"remote-connection-uuid\").then(conn => console.log(conn)).catch(err => console.log(err));\n     *\n     *\n     * // object comes back with\n     * //     token: \"0489EAC5-6404-4F0D-993B-92BB8EAB445D\", // this will be unique each time\n     * //     uuid: \"remote-connection-uuid\"\n     *\n     * ```\n     */\n    registerExternalConnection(uuid) {\n        return this.wire.sendAction('register-external-connection', { uuid }).then(({ payload }) => payload.data);\n    }\n    /**\n     * Returns the json blob found in the [desktop owner settings](https://openfin.co/documentation/desktop-owner-settings/)\n     * for the specified service.\n     * @param serviceIdentifier An object containing a name key that identifies the service.\n     *\n     * @remarks More information about desktop services can be found [here](https://developers.openfin.co/docs/desktop-services).\n     * This call will reject if the desktop owner settings file is not present, not correctly formatted, or if the service requested is not configured or configured incorrectly.\n     *\n     * @example\n     * ```js\n     * // Here we are using the [layouts](https://github.com/HadoukenIO/layouts-service) service.\n     * fin.System.getServiceConfiguration({name:'layouts'}).then(console.log).catch(console.error);\n     * ```\n     */\n    async getServiceConfiguration(serviceIdentifier) {\n        if (typeof serviceIdentifier.name !== 'string') {\n            throw new Error('Must provide an object with a `name` property having a string value');\n        }\n        const { name } = serviceIdentifier;\n        return this.wire.sendAction('get-service-configuration', { name }).then(({ payload }) => payload.data);\n    }\n    async getSystemAppConfig(name) {\n        if (typeof name !== 'string') {\n            throw new Error('Must provide a string value for name of system app');\n        }\n        return this.wire.sendAction('get-system-app-configuration', { name }).then(({ payload }) => payload.data);\n    }\n    /**\n     * Registers a system shutdown handler so user can do some cleanup before system is shutting down.\n     * @remarks Once system shutdown starts, you are unable to cancel it.\n     * @param handler system shutdown handler\n     *\n     * @example\n     * ```js\n     * fin.System.registerShutdownHandler((shutdownEvent) => {\n     *         // save state or cleanup\n     *         console.log('do some cleanup before shutdown');\n     *         // Notify app is ready for termination.\n     *         shutdownEvent.proceed();\n     * })\n     * .then(() => console.log('Shutdown handler registered!'))\n     * .catch(err => console.log(err));\n     * ```\n     * @experimental\n     */\n    async registerShutdownHandler(handler) {\n        this.wire.sendAction('system-register-shutdown-handler').catch((e) => {\n            // don't expose, analytics-only call\n        });\n        const SystemShutdownEventName = 'system-shutdown';\n        const SystemShutdownHandledEventName = 'system-shutdown-handled';\n        const { uuid, name } = this.wire.me;\n        const shutdownHandler = (payload) => {\n            const proceed = () => {\n                // notify core that the app is ready for shutdown\n                this.wire.environment.raiseEvent(`application/${SystemShutdownHandledEventName}`, {\n                    uuid,\n                    name,\n                    topic: 'application'\n                });\n            };\n            handler({ proceed });\n        };\n        this.on(SystemShutdownEventName, shutdownHandler);\n    }\n    /**\n     * Signals the RVM to perform a health check and returns the results as json.\n     *\n     * @remarks Requires RVM 5.5+\n     *\n     * @example\n     * ```js\n     * try {\n     *     const results = await fin.System.runRvmHealthCheck();\n     *     console.log(results);\n     * } catch(e) {\n     *      console.error(e);\n     * }\n     * ```\n     */\n    runRvmHealthCheck() {\n        return this.wire.sendAction('run-rvm-health-check').then(({ payload }) => payload.data);\n    }\n    /**\n     * Launch application using a manifest URL/path. It differs from Application.startFromManifest in that this API can accept a manifest using the fin protocol.\n     * @param manifestUrl - The manifest's URL or path.\n     * @param opts - Parameters that the RVM will use.\n     *\n     * @experimental\n     * @remarks Supports protocols http/s and fin/s, and also a local path.\n     *\n     * Note: This API is Windows only.\n     *\n     * @example\n     *\n     * This API can handle most manifest types. Some examples below.\n     *\n     * Traditional:\n     * ```js\n     * const manifest = await fin.System.launchManifest(\n     *   'https://demoappdirectory.openf.in/desktop/config/apps/OpenFin/HelloOpenFin/app.json');\n     * console.log(manifest);\n     * ```\n     *\n     * Platform:\n     * ```js\n     * const manifest = await fin.System.launchManifest('https://openfin.github.io/platform-api-project-seed/public.json');\n     * console.log(manifest);\n     * ```\n     *\n     * Launching traditional manifest into a platform:\n     * ```js\n     * const manifest = await fin.System.launchManifest(\n     *   'https://openfin.github.io/platform-api-project-seed/public.json?\\\n     *   $$appManifestUrl=https://demoappdirectory.openf.in/desktop/config/\\\n     *   apps/OpenFin/HelloOpenFin/app.json');\n     * console.log(manifest);\n     * ```\n     *\n     * Launching with RVM options:\n     * ```js\n     * const manifest = await fin.System.launchManifest('https://openfin.github.io/platform-api-project-seed/public.json',\n     *     { noUi: true, userAppConfigArgs: { abc: '123', xyz: '789' } });\n     * console.log(manifest);\n     * ```\n     *\n     * Local Path:\n     * ```js\n     * const manifest =  await fin.System.launchManifest('file://c:\\\\path\\\\to\\\\manifest\\\\file.json');\n     * console.log(manifest);\n     * ```\n     *\n     * Launching with RVM 'subscribe' option:\n     *\n     * This option allows users to subscribe to app version resolver events when\n     * calling launchManifest with fallbackManifests specified.\n     *\n     * ```js\n     * fin.System.launchManifest('fins://system-apps/notifications/app.json', { subscribe: (launch) => {\n     * \t\tlaunch.on('app-version-progress', (progress) => {\n     * \t\t\tconsole.log(\"Trying manifest \" + progress.manifest)\n     * \t\t});\n     *\n     * \t\tlaunch.on('runtime-status', (status) => {\n     * \t\t\tconsole.log(\"Runtime status: \" + JSON.stringify(status));\n     * \t\t});\n     *\n     * \t\t// RVM has successfully found the target runtime version\n     * \t\tlaunch.on('app-version-complete', (complete) => {\n     * \t\t\tconsole.log(\"Parent app \" + complete.srcManifest + \" resolved to \" + complete.manifest);\n     * \t\t\tlaunch.removeAllListeners();\n     * \t\t});\n     *\n     * \t\t// RVM failed to find an available runtime version\n     * \t\tlaunch.on('app-version-error', (error) => {\n     * \t\t\tconsole.log(\"Failed to resolve \" + error.srcManifest + \" from the fallbackManifests\");\n     * \t\t\tlaunch.removeAllListeners();\n     * \t\t});\n     * \t}\n     * });\n     * ```\n     */\n    async launchManifest(manifestUrl, opts = {}) {\n        const { subscribe, ..._sendOpts } = opts;\n        const sendOpts = _sendOpts;\n        if (subscribe) {\n            const launchEmitter = new events_1$6.EventEmitter();\n            subscribe(launchEmitter);\n            const AppVersionProgressEventName = 'app-version-progress';\n            const RuntimeStatusEventName = 'runtime-status';\n            const AppVersionCompleteEventName = 'app-version-complete';\n            const AppVersionErrorEventName = 'app-version-error';\n            // add id to avoid multiple api calls getting duplicated events\n            const id = this.wire.environment.getNextMessageId().toString();\n            sendOpts.appVersionId = id;\n            const supportedEvents = [\n                AppVersionCompleteEventName,\n                AppVersionProgressEventName,\n                RuntimeStatusEventName,\n                AppVersionErrorEventName\n            ];\n            const cleanEventPayload = (payload) => {\n                // We need to do type castings below to make sure the return type is correct.\n                const { appVersionId, topic, type: typeWithId, ...rest } = payload;\n                const type = supportedEvents.find((x) => typeWithId.includes(x));\n                return {\n                    ...rest,\n                    type\n                };\n            };\n            const appVersionListener = (payload) => {\n                const cleanPayload = cleanEventPayload(payload);\n                launchEmitter.emit(cleanPayload.type, cleanPayload);\n            };\n            const removeAllListeners = () => {\n                this.removeListener(`${AppVersionProgressEventName}.${id}`, appVersionListener);\n                this.removeListener(`${RuntimeStatusEventName}.${id}`, appVersionListener);\n                this.removeListener(`${AppVersionCompleteEventName}.${id}`, appVersionListener);\n                this.removeListener(`${AppVersionErrorEventName}.${id}`, appVersionListener);\n                this.removeListener(`${AppVersionCompleteEventName}.${id}`, removeAllListeners);\n                this.removeListener(`${AppVersionErrorEventName}.${id}`, removeAllListeners);\n            };\n            await Promise.all([\n                this.on(`${AppVersionProgressEventName}.${id}`, appVersionListener),\n                this.on(`${RuntimeStatusEventName}.${id}`, appVersionListener),\n                this.once(`${AppVersionCompleteEventName}.${id}`, appVersionListener),\n                this.once(`${AppVersionErrorEventName}.${id}`, appVersionListener),\n                this.once(`${AppVersionCompleteEventName}.${id}`, removeAllListeners),\n                this.once(`${AppVersionErrorEventName}.${id}`, removeAllListeners)\n            ]);\n        }\n        const response = await this.wire.sendAction('launch-manifest', {\n            manifestUrl,\n            opts: sendOpts\n        });\n        return response.payload.data.manifest;\n    }\n    /**\n     * Query permission of a secured api in current context.\n     *\n     * @param apiName - The full name of a secured API.\n     *\n     * @remarks If a function has a structured permission value, the value of `granted` will reflect the `enabled` key\n     * of the call's permissions literal.  In this case, *permission may still be denied to a call* pending arguments or other\n     * runtime state.  This is indicated with `state: unavailable`.\n     *\n     * @example\n     * ```js\n     * fin.System.queryPermissionForCurrentContext('System.launchExternalProcess').then(result => console.log(result)).catch(err => console.log(err));\n     *\n     * //This response has the following shape:\n     * {\n     *    permission: 'System.launchExternalProcess', // api full name\n     *    state: 'granted', // state of permission\n     *    granted: true\n     * }\n     * ```\n     */\n    async queryPermissionForCurrentContext(apiName) {\n        const identity = { uuid: this.wire.me.uuid, name: this.wire.me.name };\n        const response = await this.wire.sendAction('query-permission-for-current-context', {\n            apiName,\n            identity\n        });\n        return response.payload.data;\n    }\n    // Not documenting, internal use only.\n    async enableNativeWindowIntegrationProvider(permissions) {\n        const { payload } = await this.wire.sendAction('enable-native-window-integration-provider', { permissions });\n        return payload.data;\n    }\n    /**\n     * (Internal) Register the usage of a component with a platform\n     * @param options - Object with data and type\n     *\n     * @example\n     * ```js\n     * async function registerUsage() {\n     *     const app = await fin.System.getCurrent();\n     *     return await fin.System.registerUsage({\n     *         type: 'workspace-licensing',\n     *         // example values for the following data object\n     *         data: {\n     *             apiVersion: '1.0',\n     *             componentName: 'home',\n     *             componentVersion: '1.0',\n     *             allowed: true,\n     *             rejectionCode: ''\n     *         }\n     *     });\n     * }\n     *\n     * registerUsage().then(() => console.log('Successfully registered component application')).catch(err => console.log(err));\n     * ```\n     */\n    async registerUsage({ data, type }) {\n        await this.wire.sendAction('register-usage', { data, type });\n    }\n    /**\n     * Returns an array with all printers of the caller and not all the printers on the desktop.\n     *\n     * @example\n     * ```js\n     * fin.System.getPrinters()\n     *     .then((printers) => {\n     *         printers.forEach((printer) => {\n     *             if (printer.isDefault) {\n     *                 console.log(printer);\n     *             }\n     *         });\n     *     })\n     *     .catch((err) => {\n     *         console.log(err);\n     *     });\n     * ```\n     */\n    async getPrinters() {\n        const { payload } = await this.wire.sendAction('system-get-printers');\n        return payload.data;\n    }\n    /**\n     * Updates Process Logging values: periodic interval and outlier detection entries and interval.\n     * @param options Process Logging updatable options.\n     *\n     * @remarks When enabling verbose mode, additional process information is logged to the debug.log:\n     *\n     * 1. Periodically process usage (memory, cpu, etc) will be logged for each PID along with the windows, views and\n     * iframes that belong to them. The default is every 30 seconds. Updatable by passing the interval option.\n     * 2. When Windows and Views are created or navigated the PID they belong to and their options will be logged.\n     * 3. When Windows and Views are destroyed their last known process usage will be logged.\n     * 4. Whenever an outlier memory usage is detected it will be logged. By default, on an interval of 5 seconds we will\n     * collect process usage for all PIDs and when 144 such entries are collected, we will start analyzing the data for any\n     * possible outliers in the following entries. The interval and maximum number of entries stored in the running buffer\n     * can be updatable by passing the outlierDetection.interval and outlierDetection.entries options.\n     *\n     * @example\n     *\n     * ```js\n     * await fin.System.updateProcessLoggingOptions({\n     *     interval: 10,\n     *     outlierDetection: {\n     *         interval: 15,\n     *         entries: 200\n     *     }\n     * });\n     * ```\n     */\n    async updateProcessLoggingOptions(options) {\n        await this.wire.sendAction('system-update-process-logging-options', { options });\n    }\n    /**\n     * Returns domain settings for the current application.\n     * Initial settings are configured with the defaultDomainSettings application option via manifest.\n     * Domain settings can be overwritten during runtime with System.setDomainSettings.\n     * @example\n     * ```js\n     * const domainSettings = await fin.System.getDomainSettings();\n     * // {\n     * //     \"rules\": [\n     * //         {\n     * //             \"match\": [\n     * //                 \"https://openfin.co\"\n     * //             ],\n     * //             \"options\": {\n     * //                 \"downloadSettings\": {\n     * //                     \"rules\": [\n     * //                         {\n     * //                             \"match\": [\n     * //                                 \"<all_urls>\"\n     * //                             ],\n     * //                             \"behavior\": \"prompt\"\n     * //                         }\n     * //                     ]\n     * //                 }\n     * //             }\n     * //         }\n     * //     ]\n     * // }\n     * ```\n     */\n    async getDomainSettings() {\n        const { payload: { data } } = await this.wire.sendAction('get-domain-settings', this.identity);\n        return data;\n    }\n    /**\n     * Sets the domain settings for the current application.\n     * @param domainSettings - domain settings object\n     * @example\n     * ```js\n     * const domainSettings = await fin.System.getDomainSettings();\n     * // {\n     * //     \"rules\": [\n     * //         {\n     * //             \"match\": [\n     * //                 \"https://openfin.co\"\n     * //             ],\n     * //             \"options\": {\n     * //                 \"downloadSettings\": {\n     * //                     \"rules\": [\n     * //                         {\n     * //                             \"match\": [\n     * //                                 \"<all_urls>\"\n     * //                             ],\n     * //                             \"behavior\": \"prompt\"\n     * //                         }\n     * //                     ]\n     * //                 }\n     * //             }\n     * //         }\n     * //     ]\n     * // }\n     *\n     * // Valid rule behaviors are 'prompt' and 'no-prompt'\n     * domainSettings.rules[0].options.downloadSettings.rules[0].behavior = 'no-prompt';\n     *\n     * await fin.System.setDomainSettings(domainSettings);\n     *\n     * const newDomainSettings = await fin.System.getDomainSettings();\n     * // {\n     * //     \"rules\": [\n     * //         {\n     * //             \"match\": [\n     * //                 \"https://openfin.co\"\n     * //             ],\n     * //             \"options\": {\n     * //                 \"downloadSettings\": {\n     * //                     \"rules\": [\n     * //                         {\n     * //                             \"match\": [\n     * //                                 \"<all_urls>\"\n     * //                             ],\n     * //                             \"behavior\": \"no-prompt\"\n     * //                         }\n     * //                     ]\n     * //                 }\n     * //             }\n     * //         }\n     * //     ]\n     * // }\n     * ```\n     */\n    async setDomainSettings(domainSettings) {\n        await this.wire.sendAction('set-domain-settings', { domainSettings, ...this.identity });\n    }\n    /**\n     * Attempts to install and enable extensions for the security realm.  Users may want to call this function in response\n     * to an `extensions-install-failed` event.  Only extensions allowed by every application on the current security realm\n     * will be installed/enabled.\n     */\n    async refreshExtensions() {\n        const { payload } = await this.wire.sendAction('refresh-extensions');\n        return payload.data;\n    }\n    /**\n     * Gets the currently-installed\n     */\n    async getInstalledExtensions() {\n        const { payload } = await this.wire.sendAction('get-installed-extensions');\n        return payload.data;\n    }\n}\nsystem.System = System;\n\nvar interappbus = {};\n\nvar refCounter = {};\n\nObject.defineProperty(refCounter, \"__esModule\", { value: true });\nrefCounter.RefCounter = void 0;\nclass RefCounter {\n    constructor() {\n        this.topicRefMap = new Map();\n    }\n    // returns the ref count after incrementing\n    incRefCount(key) {\n        const refCount = this.topicRefMap.get(key);\n        let returnCount;\n        if (!refCount) {\n            this.topicRefMap.set(key, 1);\n            returnCount = 1;\n        }\n        else {\n            const newRefCount = refCount + 1;\n            returnCount = newRefCount;\n            this.topicRefMap.set(key, newRefCount);\n        }\n        return returnCount;\n    }\n    // returns the ref count after decrementing, or -1 if the key already had no references\n    decRefCount(key) {\n        const refCount = this.topicRefMap.get(key);\n        let returnCount;\n        if (refCount) {\n            const newRefCount = refCount - 1;\n            this.topicRefMap.set(key, newRefCount);\n            returnCount = newRefCount;\n        }\n        else {\n            returnCount = -1;\n        }\n        return returnCount;\n    }\n    // Execute firstAction if it is the first such ref, else execute nonFirstAction.\n    // In either case the return value is that of the action executed\n    actOnFirst(key, firstAction, nonFirstAction) {\n        const numRefs = this.incRefCount(key);\n        const isFirstRef = numRefs === 1;\n        return isFirstRef ? firstAction() : nonFirstAction();\n    }\n    // Execute lastAction if it is the first such ref, else execute nonLastAction.\n    // In either case the return value is that of the action executed\n    actOnLast(key, lastAction, nonLastAction) {\n        const numRefs = this.decRefCount(key);\n        const isLastRef = numRefs === 0;\n        return isLastRef ? lastAction() : nonLastAction();\n    }\n}\nrefCounter.RefCounter = RefCounter;\n\nvar channel$1 = {};\n\nvar client = {};\n\nvar channel = {};\n\nObject.defineProperty(channel, \"__esModule\", { value: true });\nchannel.ChannelBase = channel.ProtectedItems = void 0;\nconst resultOrPayload = (func) => async (topic, payload, senderIdentity) => {\n    const res = await func(topic, payload, senderIdentity);\n    return res === undefined ? payload : res;\n};\nclass ProtectedItems {\n    /**\n     * @internal\n     */\n    // eslint-disable-next-line no-useless-constructor\n    constructor(providerIdentity, close) {\n        this.providerIdentity = providerIdentity;\n        this.close = close;\n    }\n}\nchannel.ProtectedItems = ProtectedItems;\nclass ChannelBase {\n    static defaultAction(topic) {\n        throw new Error(`No action registered at target for ${topic}`);\n    }\n    constructor() {\n        this.subscriptions = new Map();\n    }\n    async processAction(topic, payload, senderIdentity) {\n        try {\n            const mainAction = this.subscriptions.has(topic)\n                ? this.subscriptions.get(topic)\n                : (currentPayload, id) => (this.defaultAction ?? ChannelBase.defaultAction)(topic, currentPayload, id);\n            const preActionProcessed = this.preAction ? await this.preAction(topic, payload, senderIdentity) : payload;\n            const actionProcessed = await mainAction(preActionProcessed, senderIdentity);\n            return this.postAction ? await this.postAction(topic, actionProcessed, senderIdentity) : actionProcessed;\n        }\n        catch (e) {\n            if (this.errorMiddleware) {\n                return this.errorMiddleware(topic, e, senderIdentity);\n            }\n            throw e;\n        }\n    }\n    /**\n     * Register middleware that fires before the action.\n     *\n     * @param func\n     *\n     * @example\n     *\n     * Channel Provider:\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     provider.register('provider-action', (payload, identity) => {\n     *         console.log(payload, identity);\n     *         return {\n     *             echo: payload\n     *         };\n     *     });\n     *\n     *     provider.beforeAction((action, payload, identity) => {\n     *         //The payload can be altered here before handling the action.\n     *         payload.received = Date.now();\n     *         return payload;\n     *     });\n     *\n     * })();\n     * ```\n     *\n     * Channel Client:\n     * ```js\n     * (async ()=> {\n     *     const client = await fin.InterApplicationBus.Channel.connect('channelName');\n     *\n     *     client.register('client-action', (payload, identity) => {\n     *         console.log(payload, identity);\n     *         return {\n     *             echo: payload\n     *         };\n     *     });\n     *\n     *     client.beforeAction((action, payload, identity) => {\n     *         //The payload can be altered here before handling the action.\n     *         payload.received = Date.now();\n     *         return payload;\n     *     });\n     *\n     *     const providerResponse = await client.dispatch('provider-action', { message: 'Hello From the client' });\n     *     console.log(providerResponse);\n     * })();\n     * ```\n     */\n    beforeAction(func) {\n        if (this.preAction) {\n            throw new Error('Already registered beforeAction middleware');\n        }\n        this.preAction = resultOrPayload(func);\n    }\n    /**\n     * Register an error handler. This is called before responding on any error.\n     *\n     * @param func\n     *\n     * Channel Provider:\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     provider.register('provider-action', (payload, identity) => {\n     *         console.log(payload);\n     *         throw new Error('Action error');\n     *         return {\n     *             echo: payload\n     *         };\n     *     });\n     *\n     *     provider.onError((action, error, identity) => {\n     *         console.log('uncaught Exception in action:', action);\n     *         console.error(error);\n     *     });\n     *\n     * })();\n     * ```\n     *\n     * Channel Client:\n     * ```js\n     * (async ()=> {\n     *     const client = await fin.InterApplicationBus.Channel.connect('channelName');\n     *\n     *     client.register('client-action', (payload, identity) => {\n     *         console.log(payload);\n     *         throw new Error('Action error');\n     *         return {\n     *             echo: payload\n     *         };\n     *     });\n     *\n     *     client.onError((action, error, identity) => {\n     *         console.log('uncaught Exception in action:', action);\n     *         console.error(error);\n     *     });\n     * })();\n     * ```\n     */\n    onError(func) {\n        if (this.errorMiddleware) {\n            throw new Error('Already registered error middleware');\n        }\n        this.errorMiddleware = func;\n    }\n    /**\n     * Register middleware that fires after the action.\n     *\n     * @param func\n     *\n     * @remarks If the action does not return the payload, then the afterAction will not have access to the payload object.\n     *\n     * @example\n     *\n     * Channel Provider:\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     await provider.register('provider-action', (payload, identity) => {\n     *         return {\n     *             echo: payload\n     *         };\n     *     });\n     *\n     *     await provider.afterAction((action, payload, identity) => {\n     *         //the payload can be altered here after handling the action but before sending an acknowledgement.\n     *         payload.sent = date.now();\n     *         return payload;\n     *     });\n     *\n     * })();\n     * ```\n     *\n     * Channel Client:\n     * ```js\n     * (async ()=> {\n     *     const client = await fin.InterApplicationBus.Channel.connect('channelName');\n     *\n     *     await client.register('client-action', (payload, identity) => {\n     *         return {\n     *             echo: payload\n     *         };\n     *     });\n     *\n     *     await client.afterAction((action, payload, identity) => {\n     *         //the payload can be altered here after handling the action but before sending an acknowledgement.\n     *         payload.sent = date.now();\n     *         return payload;\n     *     });\n     *\n     * })();\n     * ```\n     */\n    afterAction(func) {\n        if (this.postAction) {\n            throw new Error('Already registered afterAction middleware');\n        }\n        this.postAction = resultOrPayload(func);\n    }\n    /**\n     * Remove an action by action name.\n     *\n     * @param action\n     *\n     * @example\n     *\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     await provider.register('provider-action', (payload, identity) => {\n     *         console.log(payload);\n     *         return {\n     *             echo: payload\n     *         };\n     *     });\n     *\n     *     await provider.remove('provider-action');\n     *\n     * })();\n     * ```\n     */\n    remove(action) {\n        this.subscriptions.delete(action);\n    }\n    /**\n     * Registers a default action. This is used any time an action that has not been registered is invoked.\n     *\n     * @example\n     *\n     * Channel Provider:\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     await provider.setDefaultAction((action, payload, identity) => {\n     *         console.log(`Client with identity ${JSON.stringify(identity)} has attempted to dispatch unregistered action: ${action}.`);\n     *\n     *         return {\n     *             echo: payload\n     *         };\n     *     });\n     *\n     * })();\n     * ```\n     *\n     * Channel Client:\n     * ```js\n     * (async ()=> {\n     *     const client = await fin.InterApplicationBus.Channel.connect('channelName');\n     *\n     *     await client.setDefaultAction((action, payload, identity) => {\n     *         console.log(`Provider with identity ${JSON.stringify(identity)} has attempted to dispatch unregistered action: ${action}.`);\n     *\n     *         return {\n     *             echo: payload\n     *         };\n     *     });\n     *\n     * })();\n     * ```\n     * @param func\n     */\n    setDefaultAction(func) {\n        if (this.defaultAction) {\n            throw new Error('default action can only be set once');\n        }\n        else {\n            this.defaultAction = func;\n        }\n    }\n    /**\n     * Register an action to be called by dispatching from any channelClient or channelProvider.\n     *\n     * @param topic\n     * @param listener\n     *\n     * @remarks The return value will be sent back as an acknowledgement to the original caller. You can throw an\n     * error to send a negative-acknowledgement and the error will reject the promise returned to the sender by the\n     * dispatch call.  Once a listener is registered for a particular action, it stays in place receiving and responding\n     * to incoming messages until it is removed.  This messaging mechanism works exactly the same when messages are\n     * dispatched from the provider to a client.  However, the provider has an additional publish method that sends messages\n     * to all connected clients.\n     *\n     * Because multiple clients can share the same `name` and `uuid`, in order to distinguish between individual clients,\n     * the `identity` argument in a provider's registered action callback contains an `endpointId` property. When dispatching\n     * from a provider to a client, the `endpointId` property must be provided in order to send an action to a specific client.\n     *\n     * @example\n     *\n     * Channel Provider:\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     await provider.register('provider-action', (payload, identity) => {\n     *        console.log('Action dispatched by client: ', identity);\n     *        console.log('Payload sent in dispatch: ', payload);\n     *\n     *        return { echo: payload };\n     *    });\n     * })();\n     * ```\n     *\n     * Channel Client:\n     * ```js\n     * (async ()=> {\n     *     const client = await fin.InterApplicationBus.Channel.connect('channelName');\n     *\n     *     await client.register('client-action', (payload, identity) => {\n     *        console.log('Action dispatched by client: ', identity);\n     *        console.log('Payload sent in dispatch: ', payload);\n     *\n     *        return { echo: payload };\n     *    });\n     * })();\n     * ```\n     */\n    register(topic, listener) {\n        if (this.subscriptions.has(topic)) {\n            throw new Error(`Subscription already registered for action: ${topic}. Unsubscribe before adding new subscription`);\n        }\n        else {\n            this.subscriptions.set(topic, listener);\n            return true;\n        }\n    }\n}\nchannel.ChannelBase = ChannelBase;\n\nvar __classPrivateFieldGet$c = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar __classPrivateFieldSet$a = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar _ChannelClient_protectedObj, _ChannelClient_strategy, _ChannelClient_close;\nObject.defineProperty(client, \"__esModule\", { value: true });\nclient.ChannelClient = void 0;\nconst channel_1$1 = channel;\nconst channelClientsByEndpointId = new Map();\n/**\n * Instance created to enable use of a channel as a client.  Allows for communication with the\n * {@link ChannelProvider ChannelProvider} by invoking an action on the\n * provider via {@link ChannelClient#dispatch dispatch} and to listen for communication\n * from the provider by registering an action via {@link ChannelClient#register register}.\n *\n * ### Synchronous Methods:\n *  * {@link ChannelClient#onDisconnection onDisconnection(listener)}\n *  * {@link ChannelClient#register register(action, listener)}\n *  * {@link ChannelClient#remove remove(action)}\n *\n * ### Asynchronous Methods:\n *  * {@link ChannelClient#disconnect disconnect()}\n *  * {@link ChannelClient#dispatch dispatch(action, payload)}\n *\n * ### Middleware:\n * Middleware functions receive the following arguments: (action, payload, senderId).\n * The return value of the middleware function will be passed on as the payload from beforeAction, to the action listener, to afterAction\n * unless it is undefined, in which case the original payload is used.  Middleware can be used for side effects.\n *  * {@link ChannelClient#setDefaultAction setDefaultAction(middleware)}\n *  * {@link ChannelClient#onError onError(middleware)}\n *  * {@link ChannelClient#beforeAction beforeAction(middleware)}\n *  * {@link ChannelClient#afterAction afterAction(middleware)}\n */\nclass ChannelClient extends channel_1$1.ChannelBase {\n    /**\n     * @internal\n     */\n    static closeChannelByEndpointId(id) {\n        const channel = channelClientsByEndpointId.get(id);\n        if (channel) {\n            __classPrivateFieldGet$c(channel, _ChannelClient_close, \"f\").call(channel);\n        }\n    }\n    /**\n     * @internal\n     * closes the corresponding channel and invokes the disconnect listener if an event payload is passed.\n     */\n    static handleProviderDisconnect(eventPayload) {\n        for (const channelClient of channelClientsByEndpointId.values()) {\n            if (channelClient.providerIdentity.channelId === eventPayload.channelId) {\n                channelClient.disconnectListener(eventPayload);\n                __classPrivateFieldGet$c(channelClient, _ChannelClient_close, \"f\").call(channelClient);\n            }\n        }\n    }\n    /**\n     * @internal\n     */\n    constructor(routingInfo, close, strategy) {\n        super();\n        _ChannelClient_protectedObj.set(this, void 0);\n        _ChannelClient_strategy.set(this, void 0);\n        // needs to be bound;\n        this.processAction = (action, payload, senderIdentity) => super.processAction(action, payload, senderIdentity);\n        _ChannelClient_close.set(this, () => {\n            channelClientsByEndpointId.delete(this.endpointId);\n            __classPrivateFieldGet$c(this, _ChannelClient_strategy, \"f\").close();\n        });\n        __classPrivateFieldSet$a(this, _ChannelClient_protectedObj, new channel_1$1.ProtectedItems(routingInfo, close), \"f\");\n        this.disconnectListener = () => undefined;\n        this.endpointId = routingInfo.endpointId;\n        __classPrivateFieldSet$a(this, _ChannelClient_strategy, strategy, \"f\");\n        channelClientsByEndpointId.set(this.endpointId, this);\n        strategy.receive(this.processAction);\n    }\n    /**\n     * a read-only provider identity\n     */\n    get providerIdentity() {\n        const protectedObj = __classPrivateFieldGet$c(this, _ChannelClient_protectedObj, \"f\");\n        return protectedObj.providerIdentity;\n    }\n    /**\n     * Dispatch the given action to the channel provider. Returns a promise that resolves with the response from\n     * the provider for that action.\n     *\n     * @param action\n     * @param payload\n     *\n     * @example\n     *\n     * ```js\n     * (async ()=> {\n     *     const client = await fin.InterApplicationBus.Channel.connect('channelName');\n     *\n     *     await client.register('client-action', (payload, identity) => {\n     *         console.log(payload, identity);\n     *         return {\n     *             echo: payload\n     *         };\n     *     });\n     *\n     *     const providerResponse = await client.dispatch('provider-action', { message: 'Hello From the client'});\n     *     console.log(providerResponse);\n     * })();\n     * ```\n     */\n    async dispatch(action, payload) {\n        if (__classPrivateFieldGet$c(this, _ChannelClient_strategy, \"f\").isEndpointConnected(this.providerIdentity.channelId)) {\n            return __classPrivateFieldGet$c(this, _ChannelClient_strategy, \"f\").send(this.providerIdentity.channelId, action, payload);\n        }\n        throw new Error('The client you are trying to dispatch from is disconnected from the target provider.');\n    }\n    /**\n     * Register a listener that is called on provider disconnection. It is passed the disconnection event of the\n     * disconnecting provider.\n     *\n     * @param listener\n     *\n     * @example\n     *\n     * ```js\n     * (async ()=> {\n     *     const client = await fin.InterApplicationBus.Channel.connect('channelName');\n     *\n     *     await client.onDisconnection(evt => {\n     *         console.log('Provider disconnected', `uuid: ${evt.uuid}, name: ${evt.name}`);\n     *     });\n     * })();\n     * ```\n     */\n    onDisconnection(listener) {\n        this.disconnectListener = (payload) => {\n            try {\n                listener(payload);\n            }\n            catch (err) {\n                throw new Error(`Error while calling the onDisconnection callback: ${err.message}`);\n            }\n            finally {\n                this.disconnectListener = () => undefined;\n            }\n        };\n    }\n    /**\n     * Disconnects the client from the channel.\n     *\n     * @example\n     *\n     * ```js\n     * (async ()=> {\n     *     const client = await fin.InterApplicationBus.Channel.connect('channelName');\n     *\n     *     await client.disconnect();\n     * })();\n     * ```\n     */\n    async disconnect() {\n        await this.sendDisconnectAction();\n        __classPrivateFieldGet$c(this, _ChannelClient_close, \"f\").call(this);\n    }\n    async sendDisconnectAction() {\n        const protectedObj = __classPrivateFieldGet$c(this, _ChannelClient_protectedObj, \"f\");\n        await protectedObj.close();\n    }\n    /**\n     * @internal\n     * Writing this as a static to keep code together, but in environments with a wire, this will be DI'd into the protectedObject class as close.\n     */\n    static async wireClose(wire, providerIdentity, endpointId) {\n        const { channelName, uuid, name } = providerIdentity;\n        await wire.sendAction('disconnect-from-channel', {\n            channelName,\n            uuid,\n            name,\n            endpointId\n        });\n    }\n}\nclient.ChannelClient = ChannelClient;\n_ChannelClient_protectedObj = new WeakMap(), _ChannelClient_strategy = new WeakMap(), _ChannelClient_close = new WeakMap();\n\nvar connectionManager = {};\n\nvar exhaustive = {};\n\nObject.defineProperty(exhaustive, \"__esModule\", { value: true });\nexhaustive.exhaustiveCheck = void 0;\nfunction exhaustiveCheck(value, allowed) {\n    throw new Error(`Unsupported value: ${value}${allowed ? `\\n Supported values are: ${allowed.join('')}` : ''}`);\n}\nexhaustive.exhaustiveCheck = exhaustiveCheck;\n\nvar strategy$3 = {};\n\nvar __classPrivateFieldSet$9 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar __classPrivateFieldGet$b = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar _ClassicStrategy_wire, _ClassicStrategy_endpointIdentityMap, _ClassicStrategy_pendingMessagesByEndpointId;\nObject.defineProperty(strategy$3, \"__esModule\", { value: true });\nstrategy$3.ClassicInfo = strategy$3.ClassicStrategy = void 0;\n/*\nThis is used to abstract out ipc messaging from the channels implementation. It is only concerned with sending messages and registration with the MessageReceiver\n*/\nclass ClassicStrategy {\n    constructor(wire, messageReceiver, endpointId, // Provider endpointId is channelId\n    providerIdentity) {\n        this.messageReceiver = messageReceiver;\n        this.endpointId = endpointId;\n        this.providerIdentity = providerIdentity;\n        _ClassicStrategy_wire.set(this, void 0);\n        // Store full endpointIdentity by endpointId of all known endpoints for this strategy instance.\n        // (clients will only have 1: the provider, the provider will have all clients)\n        _ClassicStrategy_endpointIdentityMap.set(this, new Map());\n        // Store a set of cancellable promises to be able to reject them when client\n        // connection problems occur\n        _ClassicStrategy_pendingMessagesByEndpointId.set(this, new Map);\n        this.send = async (endpointId, action, payload) => {\n            const to = __classPrivateFieldGet$b(this, _ClassicStrategy_endpointIdentityMap, \"f\").get(endpointId);\n            if (!to) {\n                throw new Error(`Could not locate routing info for endpoint ${endpointId}`);\n            }\n            // as casting to any because typescript complains. The following is only relevant if this is a locally set endpointId on a ClientIdentity.\n            // We delete these properties to not change backwards compatibility.\n            const cleanId = { ...to };\n            if (cleanId.isLocalEndpointId) {\n                delete cleanId.endpointId;\n            }\n            delete cleanId.isLocalEndpointId;\n            // grab the promise before awaiting it to save in our pending messages map\n            const p = __classPrivateFieldGet$b(this, _ClassicStrategy_wire, \"f\")\n                .sendAction('send-channel-message', {\n                ...cleanId,\n                providerIdentity: this.providerIdentity,\n                action,\n                payload\n            });\n            __classPrivateFieldGet$b(this, _ClassicStrategy_pendingMessagesByEndpointId, \"f\").get(endpointId)?.add(p);\n            const raw = await p.catch((error) => {\n                throw new Error(error.message);\n            }).finally(() => {\n                // clean up the pending promise\n                __classPrivateFieldGet$b(this, _ClassicStrategy_pendingMessagesByEndpointId, \"f\").get(endpointId)?.delete(p);\n            });\n            return raw.payload.data.result;\n        };\n        this.close = async () => {\n            this.messageReceiver.removeEndpoint(this.providerIdentity.channelId, this.endpointId);\n            [...__classPrivateFieldGet$b(this, _ClassicStrategy_endpointIdentityMap, \"f\").keys()].forEach((id) => this.closeEndpoint(id));\n            __classPrivateFieldSet$9(this, _ClassicStrategy_endpointIdentityMap, new Map(), \"f\");\n        };\n        __classPrivateFieldSet$9(this, _ClassicStrategy_wire, wire, \"f\");\n    }\n    onEndpointDisconnect(endpointId, listener) {\n        // Never fires for 'classic'.\n    }\n    receive(listener) {\n        this.messageReceiver.addEndpoint(listener, this.providerIdentity.channelId, this.endpointId);\n    }\n    async closeEndpoint(endpointId) {\n        const id = __classPrivateFieldGet$b(this, _ClassicStrategy_endpointIdentityMap, \"f\").get(endpointId);\n        __classPrivateFieldGet$b(this, _ClassicStrategy_endpointIdentityMap, \"f\").delete(endpointId);\n        const pendingSet = __classPrivateFieldGet$b(this, _ClassicStrategy_pendingMessagesByEndpointId, \"f\").get(endpointId);\n        pendingSet?.forEach((p) => {\n            const errorMsg = `Channel connection with identity uuid: ${id?.uuid} / name: ${id?.name} / endpointId: ${endpointId} no longer connected.`;\n            p.cancel(new Error(errorMsg));\n        });\n    }\n    isEndpointConnected(endpointId) {\n        return __classPrivateFieldGet$b(this, _ClassicStrategy_endpointIdentityMap, \"f\").has(endpointId);\n    }\n    addEndpoint(endpointId, payload) {\n        __classPrivateFieldGet$b(this, _ClassicStrategy_endpointIdentityMap, \"f\").set(endpointId, payload.endpointIdentity);\n        __classPrivateFieldGet$b(this, _ClassicStrategy_pendingMessagesByEndpointId, \"f\").set(endpointId, new Set());\n    }\n    isValidEndpointPayload(payload) {\n        return (typeof payload?.endpointIdentity?.endpointId === 'string' ||\n            typeof payload?.endpointIdentity?.channelId === 'string');\n    }\n}\nstrategy$3.ClassicStrategy = ClassicStrategy;\n_ClassicStrategy_wire = new WeakMap(), _ClassicStrategy_endpointIdentityMap = new WeakMap(), _ClassicStrategy_pendingMessagesByEndpointId = new WeakMap();\n// Arbitrarily starting at 5 to leave the door open to backfilling pre endpointId etc.\nstrategy$3.ClassicInfo = { version: 5, minimumVersion: 0, type: 'classic' };\n\nvar strategy$2 = {};\n\nvar endpoint = {};\n\nvar errors = {};\n\nObject.defineProperty(errors, \"__esModule\", { value: true });\nerrors.errorToPOJO = void 0;\nfunction errorToPOJO(error) {\n    return {\n        stack: error.stack,\n        name: error.name,\n        message: error.message,\n        // support the case where stack is empty or missing\n        toString: () => error.stack || error.toString()\n    };\n}\nerrors.errorToPOJO = errorToPOJO;\n\nvar __classPrivateFieldGet$a = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar __classPrivateFieldSet$8 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar _RTCEndpoint_processAction, _RTCEndpoint_disconnectListener;\nObject.defineProperty(endpoint, \"__esModule\", { value: true });\nendpoint.RTCEndpoint = void 0;\n/* eslint-disable @typescript-eslint/no-unused-vars */\nconst errors_1$1 = errors;\n/*\nThis handles sending RTC messages between RTC connections over the request and response data channels.\n*/\nclass RTCEndpoint {\n    static isValidEndpointPayload(payload) {\n        const isObject = (x) => {\n            return typeof x === 'object' && x !== null;\n        };\n        return (\n        // TODO in factory PR:\n        // payload.type === 'rtc' &&\n        isObject(payload) &&\n            isObject(payload.endpointIdentity) &&\n            isObject(payload.rtc) &&\n            typeof payload.endpointIdentity.endpointId === 'string');\n    }\n    constructor({ rtc, endpointIdentity }) {\n        this.responseMap = new Map();\n        _RTCEndpoint_processAction.set(this, null);\n        _RTCEndpoint_disconnectListener.set(this, void 0);\n        this.connectionStateChangeHandler = (event) => {\n            if (this.rtc.rtcClient.connectionState !== 'connected') {\n                this.rtc.rtcClient.removeEventListener('connectionstatechange', this.connectionStateChangeHandler);\n                this.close();\n                if (__classPrivateFieldGet$a(this, _RTCEndpoint_disconnectListener, \"f\")) {\n                    __classPrivateFieldGet$a(this, _RTCEndpoint_disconnectListener, \"f\").call(this);\n                }\n            }\n        };\n        this.send = async (action, payload) => {\n            const messageId = `message-${Math.random()}`;\n            const promise = new Promise((resolve, reject) => {\n                this.responseMap.set(messageId, { resolve, reject });\n            });\n            this.rtc.channels.request.send(JSON.stringify({ action, payload, messageId }));\n            return promise;\n        };\n        this.close = () => {\n            this.responseMap.forEach((response) => response.reject('Connection has closed.'));\n            this.responseMap = new Map();\n            this.rtc.channels.request.close();\n            this.rtc.channels.response.close();\n            this.rtc.rtcClient.close();\n        };\n        this.rtc = rtc;\n        this.endpointIdentity = endpointIdentity;\n        this.rtc.channels.response.addEventListener('message', (e) => {\n            let { data } = e;\n            if (e.data instanceof ArrayBuffer) {\n                data = new TextDecoder().decode(e.data);\n            }\n            const { messageId, payload, success, error } = JSON.parse(data);\n            const { resolve, reject } = this.responseMap.get(messageId) ?? {};\n            if (resolve && reject) {\n                this.responseMap.delete(messageId);\n                if (success) {\n                    resolve(payload);\n                }\n                else {\n                    reject(error);\n                }\n            }\n            else {\n                console.log('Could not find id in responseMap.');\n                console.log(e);\n            }\n        });\n        this.rtc.channels.request.addEventListener('message', async (e) => {\n            let { data } = e;\n            if (e.data instanceof ArrayBuffer) {\n                data = new TextDecoder().decode(e.data);\n            }\n            const { messageId, action, payload } = JSON.parse(data);\n            if (__classPrivateFieldGet$a(this, _RTCEndpoint_processAction, \"f\")) {\n                try {\n                    const res = await __classPrivateFieldGet$a(this, _RTCEndpoint_processAction, \"f\").call(this, action, payload, endpointIdentity);\n                    this.rtc.channels.response.send(JSON.stringify({\n                        messageId,\n                        payload: res,\n                        success: true\n                    }));\n                }\n                catch (error) {\n                    // Check if RTCDataChannel is open before sending, error gets swallowed here in the case where\n                    // client dispatched then closed or disconnected before the dispatch resolves.\n                    if (this.rtc.channels.response.readyState === 'open') {\n                        this.rtc.channels.response.send(JSON.stringify({\n                            messageId,\n                            error: (0, errors_1$1.errorToPOJO)(error),\n                            success: false\n                        }));\n                    }\n                }\n                // Check if RTCDataChannel is open for same reason as catch block above.\n            }\n            else if (this.rtc.channels.response.readyState === 'open') {\n                this.rtc.channels.response.send(JSON.stringify({\n                    messageId,\n                    success: false,\n                    error: 'Connection not ready.'\n                }));\n            }\n        });\n        this.rtc.rtcClient.addEventListener('connectionstatechange', this.connectionStateChangeHandler);\n        // Disconnect if data channels close unexpectedly, e.g. can happen due to message size > ~255kB (RTCPeerConnection.sctp.maxMessageSizeLimit: 262144)\n        Object.values(this.rtc.channels).forEach((datachannel) => {\n            datachannel.onclose = (e) => {\n                [...this.responseMap.values()].forEach((promise) => promise.reject(new Error('RTCDataChannel closed unexpectedly, this is most commonly caused by message size. Note: RTC Channels have a message size limit of ~255kB.')));\n                this.close();\n                if (__classPrivateFieldGet$a(this, _RTCEndpoint_disconnectListener, \"f\")) {\n                    __classPrivateFieldGet$a(this, _RTCEndpoint_disconnectListener, \"f\").call(this);\n                }\n            };\n        });\n    }\n    onDisconnect(listener) {\n        if (!__classPrivateFieldGet$a(this, _RTCEndpoint_disconnectListener, \"f\")) {\n            __classPrivateFieldSet$8(this, _RTCEndpoint_disconnectListener, listener, \"f\");\n        }\n        else {\n            throw new Error('RTCEndpoint disconnectListener cannot be set twice.');\n        }\n    }\n    receive(listener) {\n        if (__classPrivateFieldGet$a(this, _RTCEndpoint_processAction, \"f\")) {\n            throw new Error('You have already set a listener for this RTC Endpoint.');\n        }\n        __classPrivateFieldSet$8(this, _RTCEndpoint_processAction, listener, \"f\");\n    }\n    get connected() {\n        return this.rtc.rtcClient.connectionState === 'connected';\n    }\n}\nendpoint.RTCEndpoint = RTCEndpoint;\n_RTCEndpoint_processAction = new WeakMap(), _RTCEndpoint_disconnectListener = new WeakMap();\n\nvar strategy$1 = {};\n\nvar __classPrivateFieldGet$9 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar __classPrivateFieldSet$7 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar _EndpointStrategy_processAction, _EndpointStrategy_endpointMap, _EndpointStrategy_connected;\nObject.defineProperty(strategy$1, \"__esModule\", { value: true });\nstrategy$1.EndpointStrategy = void 0;\nclass EndpointStrategy {\n    // Need to pass in validate endpoint separately from constructor because ts interfaces don't do well with static methods\n    constructor(EndpointType, validateEndpoint, StrategyName) {\n        this.EndpointType = EndpointType;\n        this.StrategyName = StrategyName;\n        _EndpointStrategy_processAction.set(this, null);\n        _EndpointStrategy_endpointMap.set(this, new Map());\n        _EndpointStrategy_connected.set(this, true);\n        this.send = async (endpointId, action, payload) => {\n            return this.getEndpointById(endpointId).send(action, payload);\n        };\n        this.close = async () => {\n            if (__classPrivateFieldGet$9(this, _EndpointStrategy_connected, \"f\")) {\n                __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, \"f\").forEach((endpoint) => endpoint.close());\n                __classPrivateFieldSet$7(this, _EndpointStrategy_endpointMap, new Map(), \"f\");\n            }\n            __classPrivateFieldSet$7(this, _EndpointStrategy_connected, false, \"f\");\n        };\n        this.isValidEndpointPayload = validateEndpoint;\n    }\n    onEndpointDisconnect(endpointId, listener) {\n        this.getEndpointById(endpointId).onDisconnect(listener);\n    }\n    receive(listener) {\n        if (__classPrivateFieldGet$9(this, _EndpointStrategy_processAction, \"f\")) {\n            throw new Error(`You have already set a listener for this ${this.StrategyName} Strategy`);\n        }\n        __classPrivateFieldSet$7(this, _EndpointStrategy_processAction, listener, \"f\");\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, \"f\").forEach((endpoint) => endpoint.receive(__classPrivateFieldGet$9(this, _EndpointStrategy_processAction, \"f\")));\n    }\n    getEndpointById(endpointId) {\n        const endpoint = __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, \"f\").get(endpointId);\n        if (!endpoint) {\n            throw new Error(`Client with endpoint id ${endpointId} is not connected`);\n        }\n        return endpoint;\n    }\n    get connected() {\n        return __classPrivateFieldGet$9(this, _EndpointStrategy_connected, \"f\");\n    }\n    isEndpointConnected(endpointId) {\n        return __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, \"f\").has(endpointId);\n    }\n    addEndpoint(endpointId, payload) {\n        if (!__classPrivateFieldGet$9(this, _EndpointStrategy_connected, \"f\")) {\n            console.warn(`Adding endpoint to disconnected ${this.StrategyName} Strategy`);\n            return;\n        }\n        const clientStrat = new this.EndpointType(payload);\n        if (__classPrivateFieldGet$9(this, _EndpointStrategy_processAction, \"f\")) {\n            clientStrat.receive(__classPrivateFieldGet$9(this, _EndpointStrategy_processAction, \"f\"));\n        }\n        __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, \"f\").set(endpointId, clientStrat);\n    }\n    async closeEndpoint(endpointId) {\n        __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, \"f\").delete(endpointId);\n    }\n}\nstrategy$1.EndpointStrategy = EndpointStrategy;\n_EndpointStrategy_processAction = new WeakMap(), _EndpointStrategy_endpointMap = new WeakMap(), _EndpointStrategy_connected = new WeakMap();\n\nObject.defineProperty(strategy$2, \"__esModule\", { value: true });\nstrategy$2.RTCInfo = strategy$2.RTCStrategy = void 0;\n/* eslint-disable @typescript-eslint/no-unused-vars */\n/* eslint-disable class-methods-use-this */\nconst endpoint_1 = endpoint;\nconst strategy_1$1 = strategy$1;\n/*\nThis is used to abstract out rtc messaging from the channels implementation using RTCEndpoints.\n*/\nclass RTCStrategy extends strategy_1$1.EndpointStrategy {\n    constructor() {\n        super(endpoint_1.RTCEndpoint, endpoint_1.RTCEndpoint.isValidEndpointPayload, 'RTC');\n    }\n}\nstrategy$2.RTCStrategy = RTCStrategy;\nstrategy$2.RTCInfo = { version: 2, minimumVersion: 0, type: 'rtc' };\n\nvar iceManager = {};\n\nObject.defineProperty(iceManager, \"__esModule\", { value: true });\niceManager.RTCICEManager = void 0;\nconst base_1$h = base;\n/*\nSingleton that facilitates Offer and Answer exchange required for establishing RTC connections.\n*/\nclass RTCICEManager extends base_1$h.EmitterBase {\n    constructor(wire) {\n        super(wire, 'channel');\n        this.ensureChannelOpened = (channel) => {\n            return new Promise((resolve, reject) => {\n                if (channel.readyState === 'open') {\n                    resolve();\n                }\n                else if (channel.readyState === 'connecting') {\n                    const listener = () => {\n                        channel.removeEventListener('open', listener);\n                        resolve();\n                    };\n                    channel.addEventListener('open', listener);\n                }\n                else {\n                    reject(new Error('This Channel has already closed'));\n                }\n            });\n        };\n    }\n    static createDataChannelPromise(label, rtcClient) {\n        let resolver;\n        const promise = new Promise((resolve) => {\n            resolver = resolve;\n        });\n        const listener = (e) => {\n            const openListener = () => {\n                e.channel.removeEventListener('open', openListener);\n                resolver(e.channel);\n            };\n            if (e.channel.label === label) {\n                e.channel.addEventListener('open', openListener);\n                rtcClient.removeEventListener('datachannel', listener);\n            }\n        };\n        rtcClient.addEventListener('datachannel', listener);\n        return promise;\n    }\n    async listenForProviderIce(rtcConnectionId, listener) {\n        await this.on(this.createProviderEventName(rtcConnectionId), listener, { timestamp: Date.now() });\n    }\n    async raiseProviderIce(rtcConnectionId, payload) {\n        await this.wire.environment.raiseEvent(this.createRouteString(this.createProviderEventName(rtcConnectionId)), payload);\n    }\n    async listenForClientIce(rtcConnectionId, listener) {\n        await this.on(this.createClientEventName(rtcConnectionId), listener, { timestamp: Date.now() });\n    }\n    async raiseClientIce(rtcConnectionId, payload) {\n        await this.wire.environment.raiseEvent(this.createRouteString(this.createClientEventName(rtcConnectionId)), payload);\n    }\n    cleanupIceListeners(rtcConnectionId) {\n        this.removeAllListeners(this.createClientEventName(rtcConnectionId));\n        this.removeAllListeners(this.createProviderEventName(rtcConnectionId));\n    }\n    createClientEventName(rtcConnectionId) {\n        return `ice-client-${rtcConnectionId}`;\n    }\n    createProviderEventName(rtcConnectionId) {\n        return `ice-provider-${rtcConnectionId}`;\n    }\n    createRouteString(name) {\n        return `channel/${name}`;\n    }\n    createRtcPeer() {\n        return this.wire.environment.getRtcPeer();\n    }\n    async startClientOffer() {\n        // TODO replace with real guid.\n        const rtcConnectionId = Math.random().toString();\n        const rtcClient = this.createRtcPeer();\n        rtcClient.addEventListener('icecandidate', async (e) => {\n            if (e.candidate) {\n                await this.raiseClientIce(rtcConnectionId, { candidate: e.candidate?.toJSON() });\n            }\n        });\n        await this.listenForProviderIce(rtcConnectionId, async (payload) => {\n            await rtcClient.addIceCandidate(payload.candidate);\n        });\n        const channels = {\n            request: rtcClient.createDataChannel('request'),\n            response: rtcClient.createDataChannel('response')\n        };\n        const offer = await rtcClient.createOffer();\n        await rtcClient.setLocalDescription(offer);\n        const channelsOpened = Promise.all([channels.request, channels.response].map(this.ensureChannelOpened)).then(() => undefined);\n        return { rtcClient, channels, offer, rtcConnectionId, channelsOpened };\n    }\n    async finishClientOffer(rtcClient, answer, providerReady) {\n        await rtcClient.setRemoteDescription(answer);\n        await providerReady;\n        return true;\n    }\n    async createProviderAnswer(rtcConnectionId, offer) {\n        const rtcClient = this.createRtcPeer();\n        const requestChannelPromise = RTCICEManager.createDataChannelPromise('request', rtcClient);\n        const responseChannelPromise = RTCICEManager.createDataChannelPromise('response', rtcClient);\n        rtcClient.addEventListener('icecandidate', async (e) => {\n            if (e.candidate) {\n                await this.raiseProviderIce(rtcConnectionId, { candidate: e.candidate?.toJSON() });\n            }\n        });\n        await this.listenForClientIce(rtcConnectionId, async (payload) => {\n            await rtcClient.addIceCandidate(payload.candidate);\n        });\n        await rtcClient.setRemoteDescription(offer);\n        const answer = await rtcClient.createAnswer();\n        await rtcClient.setLocalDescription(answer);\n        const channels = Promise.all([requestChannelPromise, responseChannelPromise]).then(([request, response]) => {\n            // Clean up ice events.\n            this.cleanupIceListeners(rtcConnectionId);\n            return { request, response };\n        });\n        return {\n            rtcClient,\n            answer,\n            channels\n        };\n    }\n}\niceManager.RTCICEManager = RTCICEManager;\n\nvar provider = {};\n\nvar runtimeVersioning = {};\n\nObject.defineProperty(runtimeVersioning, \"__esModule\", { value: true });\nruntimeVersioning.runtimeUuidMeetsMinimumRuntimeVersion = runtimeVersioning.parseRuntimeUuid = runtimeVersioning.meetsMinimumRuntimeVersion = void 0;\nfunction vNum(x) {\n    return [...x.split('.').reverse().entries()].reduce((p, [i, v]) => p + +v * 10000 ** i, 0);\n}\n/*\n  Compares runtime versions to see if the current runtime meets your desired minimum.\n*/\nfunction meetsMinimumRuntimeVersion(currentVersion, minVersion) {\n    const currentVersionParsed = vNum(currentVersion);\n    const minVersionParsed = vNum(minVersion);\n    return currentVersionParsed >= minVersionParsed;\n}\nruntimeVersioning.meetsMinimumRuntimeVersion = meetsMinimumRuntimeVersion;\n// Strips the port info from the runtimeUuid, leaving just the runtime version.\nfunction parseRuntimeUuid(runtimeUuid) {\n    return runtimeUuid.split('/')[0];\n}\nruntimeVersioning.parseRuntimeUuid = parseRuntimeUuid;\nfunction runtimeUuidMeetsMinimumRuntimeVersion(runtimeUuid, minVersion) {\n    const runtimeVersion = parseRuntimeUuid(runtimeUuid);\n    return meetsMinimumRuntimeVersion(runtimeVersion, minVersion);\n}\nruntimeVersioning.runtimeUuidMeetsMinimumRuntimeVersion = runtimeUuidMeetsMinimumRuntimeVersion;\n\nvar __classPrivateFieldGet$8 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar __classPrivateFieldSet$6 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar _ChannelProvider_connections, _ChannelProvider_protectedObj, _ChannelProvider_strategy, _ChannelProvider_removeEndpoint, _ChannelProvider_close;\nObject.defineProperty(provider, \"__esModule\", { value: true });\nprovider.ChannelProvider = void 0;\nconst channel_1 = channel;\nconst runtimeVersioning_1 = runtimeVersioning;\n/**\n * Instance created to enable use of a channel as a provider. Allows for communication with the {@link ChannelClient ChannelClients} by invoking an action on\n * a single client via {@link ChannelProvider#dispatch dispatch} or all clients via {@link ChannelProvider#publish publish}\n * and to listen for communication from clients by registering an action via {@link ChannelProvider#register register}.\n *\n * ### Synchronous Methods:\n *  * {@link ChannelProvider#onConnection onConnection(listener)}\n *  * {@link ChannelProvider#onDisconnection onDisconnection(listener)}\n *  * {@link ChannelProvider#publish publish(action, payload)}\n *  * {@link ChannelProvider#register register(action, listener)}\n *  * {@link ChannelProvider#remove remove(action)}\n *\n * ### Asynchronous Methods:\n *  * {@link ChannelProvider#destroy destroy()}\n *  * {@link ChannelProvider#dispatch dispatch(to, action, payload)}\n *  * {@link ChannelProvider#getAllClientInfo getAllClientInfo()}\n *\n * ### Middleware:\n * Middleware functions receive the following arguments: (action, payload, senderId).\n * The return value of the middleware function will be passed on as the payload from beforeAction, to the action listener, to afterAction\n * unless it is undefined, in which case the most recently defined payload is used.  Middleware can be used for side effects.\n *  * {@link ChannelProvider#setDefaultAction setDefaultAction(middleware)}\n *  * {@link ChannelProvider#onError onError(middleware)}\n *  * {@link ChannelProvider#beforeAction beforeAction(middleware)}\n *  * {@link ChannelProvider#afterAction afterAction(middleware)}\n */\nclass ChannelProvider extends channel_1.ChannelBase {\n    /**\n     * a read-only array containing all the identities of connecting clients.\n     */\n    get connections() {\n        return [...__classPrivateFieldGet$8(this, _ChannelProvider_connections, \"f\")];\n    }\n    static handleClientDisconnection(channel, payload) {\n        const removeById = channel.connections.find((identity) => identity.endpointId === payload.endpointId);\n        if (removeById) {\n            __classPrivateFieldGet$8(channel, _ChannelProvider_removeEndpoint, \"f\").call(channel, removeById);\n        }\n        else {\n            const multipleRemoves = channel.connections.filter((identity) => {\n                return identity.uuid === payload.uuid && identity.name === payload.name;\n            });\n            multipleRemoves.forEach(__classPrivateFieldGet$8(channel, _ChannelProvider_removeEndpoint, \"f\"));\n        }\n        channel.disconnectListener(payload);\n    }\n    static setProviderRemoval(provider, remove) {\n        ChannelProvider.removalMap.set(provider, remove);\n    }\n    /**\n     * @internal\n     */\n    constructor(providerIdentity, close, strategy) {\n        super();\n        _ChannelProvider_connections.set(this, void 0);\n        _ChannelProvider_protectedObj.set(this, void 0);\n        _ChannelProvider_strategy.set(this, void 0);\n        _ChannelProvider_removeEndpoint.set(this, (identity) => {\n            const remainingConnections = this.connections.filter((clientIdentity) => clientIdentity.endpointId !== identity.endpointId);\n            __classPrivateFieldGet$8(this, _ChannelProvider_strategy, \"f\").closeEndpoint(identity.endpointId);\n            __classPrivateFieldSet$6(this, _ChannelProvider_connections, remainingConnections, \"f\");\n        });\n        // Must be bound.\n        this.processAction = async (action, payload, senderIdentity) => {\n            if (ChannelProvider.clientIsMultiRuntime(senderIdentity) &&\n                !(0, runtimeVersioning_1.runtimeUuidMeetsMinimumRuntimeVersion)(senderIdentity.runtimeUuid, '18.87.56.0')) {\n                this.handleMultiRuntimeLegacyClient(senderIdentity);\n            }\n            else {\n                this.checkForClientConnection(senderIdentity);\n            }\n            return super.processAction(action, payload, senderIdentity);\n        };\n        _ChannelProvider_close.set(this, () => {\n            __classPrivateFieldGet$8(this, _ChannelProvider_strategy, \"f\").close();\n            const remove = ChannelProvider.removalMap.get(this);\n            if (remove) {\n                remove();\n            }\n        });\n        __classPrivateFieldSet$6(this, _ChannelProvider_protectedObj, new channel_1.ProtectedItems(providerIdentity, close), \"f\");\n        this.connectListener = () => undefined;\n        this.disconnectListener = () => undefined;\n        __classPrivateFieldSet$6(this, _ChannelProvider_connections, [], \"f\");\n        __classPrivateFieldSet$6(this, _ChannelProvider_strategy, strategy, \"f\");\n        strategy.receive(this.processAction);\n    }\n    /**\n     * Dispatch an action to a specified client. Returns a promise for the result of executing that action on the client side.\n     *\n     * @param to - Identity of the target client.\n     * @param action - Name of the action to be invoked by the client.\n     * @param payload - Payload to be sent along with the action.\n     *\n     * @remarks\n     *\n     * Because multiple clients can share the same `name` and `uuid`, when dispatching from a provider to a client,\n     * the `identity` you provide must include the client's unique `endpointId` property. This `endpointId` is\n     * passed to the provider in both the `Provider.onConnection` callback and in any registered action callbacks.\n     *\n     * @example\n     *\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     await provider.register('provider-action', async (payload, identity) => {\n     *         console.log(payload, identity);\n     *         return await provider.dispatch(identity, 'client-action', 'Hello, World!');\n     *     });\n     * })();\n     * ```\n     */\n    dispatch(to, action, payload) {\n        const endpointId = to.endpointId ?? this.getEndpointIdForOpenFinId(to, action);\n        if (endpointId && __classPrivateFieldGet$8(this, _ChannelProvider_strategy, \"f\").isEndpointConnected(endpointId)) {\n            return __classPrivateFieldGet$8(this, _ChannelProvider_strategy, \"f\").send(endpointId, action, payload);\n        }\n        return Promise.reject(new Error(`Client connection with identity uuid: ${to.uuid} / name: ${to.name} / endpointId: ${endpointId} no longer connected.`));\n    }\n    async processConnection(senderId, payload) {\n        __classPrivateFieldGet$8(this, _ChannelProvider_connections, \"f\").push(senderId);\n        return this.connectListener(senderId, payload);\n    }\n    /**\n     * Publish an action and payload to every connected client.\n     * Synchronously returns an array of promises for each action (see dispatch).\n     *\n     * @param action\n     * @param payload\n     *\n     * @example\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     await provider.register('provider-action', async (payload, identity) => {\n     *         console.log(payload, identity);\n     *         return await Promise.all(provider.publish('client-action', { message: 'Broadcast from provider'}));\n     *     });\n     * })();\n     * ```\n     */\n    publish(action, payload) {\n        return this.connections.map((to) => __classPrivateFieldGet$8(this, _ChannelProvider_strategy, \"f\").send(to.endpointId, action, payload));\n    }\n    /**\n     * Register a listener that is called on every new client connection.\n     *\n     * @remarks It is passed the identity of the connecting client and a payload if it was provided to Channel.connect.\n     * If you wish to reject the connection, throw an error. Be sure to synchronously provide an onConnection upon receipt of\n     * the channelProvider to ensure all potential client connections are caught by the listener.\n     *\n     * Because multiple clients can exist at the same `name` and `uuid`, in order to distinguish between individual clients,\n     * the `identity` argument in a provider's `onConnection` callback contains an `endpointId` property. When dispatching from a\n     * provider to a client, the `endpointId` property must be provided in order to send an action to a specific client.\n     *\n     * @example\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     provider.onConnection(identity => {\n     *         console.log('Client connected', identity);\n     *     });\n     * })();\n     * ```\n     *\n     * Reject connection:\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     provider.onConnection(identity => {\n     *         throw new Error('Connection Rejected');\n     *     });\n     * })();\n     * ```\n     * @param listener\n     */\n    onConnection(listener) {\n        this.connectListener = listener;\n    }\n    /**\n     * Register a listener that is called on client disconnection. It is passed the disconnection event of the disconnecting\n     * client.\n     *\n     * @param listener\n     *\n     * @example\n     *\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     await provider.onDisconnection(evt => {\n     *         console.log('Client disconnected', `uuid: ${evt.uuid}, name: ${evt.name}`);\n     *     });\n     * })();\n     * ```\n     */\n    onDisconnection(listener) {\n        this.disconnectListener = listener;\n    }\n    /**\n     * Destroy the channel, raises `disconnected` events on all connected channel clients.\n     *\n     * @example\n     *\n     * ```js\n     * (async ()=> {\n     *     const provider = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *     await provider.destroy();\n     * })();\n     * ```\n     */\n    async destroy() {\n        const protectedObj = __classPrivateFieldGet$8(this, _ChannelProvider_protectedObj, \"f\");\n        protectedObj.providerIdentity;\n        __classPrivateFieldSet$6(this, _ChannelProvider_connections, [], \"f\");\n        await protectedObj.close();\n        __classPrivateFieldGet$8(this, _ChannelProvider_close, \"f\").call(this);\n    }\n    /**\n     * Returns an array with info on every Client connected to the Provider\n     *\n     * @example\n     *\n     * ```js\n     * const provider = await fin.InterApplicationBus.Channel.create('openfin');\n     * const client = await fin.InterApplicationBus.Channel.connect('openfin');\n     * const clientInfo = await provider.getAllClientInfo();\n     *\n     * console.log(clientInfo);\n     *\n     * // [\n     * //    {\n     * //        \"uuid\": \"openfin\",\n     * //        \"name\": \"openfin-view\",\n     * //        \"endpointId\": \"6d4c7ca8-4a74-4634-87f8-760558229613\",\n     * //        \"entityType\": \"view\",\n     * //        \"url\": \"https://openfin.co\"\n     * //    },\n     * //    {\n     * //        \"uuid\": \"openfin2\",\n     * //        \"name\": \"openfin-view2\",\n     * //        \"endpointId\": \"4z5d8ab9-2b81-3691-91ex-142179382511\",\n     * //        \"entityType\": \"view\",\n     * //        \"url\": \"https://example.com\"\n     * //    }\n     * //]\n     * ```\n     */\n    async getAllClientInfo() {\n        return this.connections.map((clientInfo) => {\n            const { uuid, name, endpointId, entityType, connectionUrl } = clientInfo;\n            return { uuid, name, endpointId, entityType, connectionUrl };\n        });\n    }\n    checkForClientConnection(clientIdentity) {\n        if (!this.isClientConnected(clientIdentity)) {\n            throw new Error(`This action was sent from a client that is not connected to the provider.\n                    Client Identity: {uuid: ${clientIdentity.uuid}, name: ${clientIdentity.name}, endpointId: ${clientIdentity.endpointId}}`);\n        }\n    }\n    isClientConnected(clientIdentity) {\n        if (ChannelProvider.clientIdentityIncludesEndpointId(clientIdentity)) {\n            return this.connections.some((identity) => {\n                return (\n                // Might be redundant to check for uuid and name here after we get an endpointId match, but just in case\n                identity.endpointId === clientIdentity.endpointId &&\n                    identity.uuid === clientIdentity.uuid &&\n                    identity.name === clientIdentity.name);\n            });\n        }\n        return this.isLegacyClientConnected(clientIdentity);\n    }\n    isLegacyClientConnected(clientIdentity) {\n        return this.connections.some((identity) => {\n            return identity.uuid === clientIdentity.uuid && identity.name === clientIdentity.name;\n        });\n    }\n    handleMultiRuntimeLegacyClient(senderIdentity) {\n        if (!this.isLegacyClientConnected(senderIdentity)) {\n            throw new Error(`This action was sent from a client that is not connected to the provider. Client Identity:\n                    {uuid: ${senderIdentity.uuid}, name: ${senderIdentity.name}, endpointId: ${senderIdentity.endpointId}}`);\n        }\n    }\n    getEndpointIdForOpenFinId(clientIdentity, action) {\n        const matchingConnections = this.connections.filter((c) => c.name === clientIdentity.name && c.uuid === clientIdentity.uuid);\n        if (matchingConnections.length >= 2) {\n            const protectedObj = __classPrivateFieldGet$8(this, _ChannelProvider_protectedObj, \"f\");\n            const { uuid, name } = clientIdentity;\n            const providerUuid = protectedObj?.providerIdentity.uuid;\n            const providerName = protectedObj?.providerIdentity.name;\n            // eslint-disable-next-line no-console\n            console.warn(`WARNING: Dispatch call may have unintended results. The \"to\" argument of your dispatch call is missing the\n                \"endpointId\" parameter. The identity you are dispatching to ({uuid: ${uuid}, name: ${name}})\n                has multiple channelClients for this channel. Your dispatched action: (${action}) from the provider:\n                ({uuid: ${providerUuid}, name: ${providerName}}) will only be processed by the most recently-created client.`);\n        }\n        // Pop to return the most recently created endpointId.\n        return matchingConnections.pop()?.endpointId;\n    }\n    // eslint-disable-next-line class-methods-use-this\n    static clientIdentityIncludesEndpointId(subscriptionIdentity) {\n        return subscriptionIdentity.endpointId !== undefined;\n    }\n    // eslint-disable-next-line class-methods-use-this\n    static clientIsMultiRuntime(subscriptionIdentity) {\n        return subscriptionIdentity.runtimeUuid !== undefined;\n    }\n    static async wireClose(wire, channelName) {\n        await wire.sendAction('destroy-channel', { channelName });\n    }\n}\nprovider.ChannelProvider = ChannelProvider;\n_ChannelProvider_connections = new WeakMap(), _ChannelProvider_protectedObj = new WeakMap(), _ChannelProvider_strategy = new WeakMap(), _ChannelProvider_removeEndpoint = new WeakMap(), _ChannelProvider_close = new WeakMap();\n// The following line should be changed following a typescript update.\n// static #removalMap = new WeakMap<ChannelProvider, Function>();\nChannelProvider.removalMap = new WeakMap();\n\nvar messageReceiver = {};\n\nObject.defineProperty(messageReceiver, \"__esModule\", { value: true });\nmessageReceiver.MessageReceiver = void 0;\nconst client_1$1 = client;\nconst base_1$g = base;\n/*\nThis is a singleton (per fin object) tasked with routing messages coming off the ipc to the correct endpoint.\nIt needs to be a singleton because there can only be one per wire. It tracks both clients and providers' processAction passed in via the strategy.\nIf functionality is not about receiving messages, it does not belong here.\n*/\nclass MessageReceiver extends base_1$g.Base {\n    constructor(wire) {\n        super(wire);\n        this.onmessage = (msg) => {\n            if (msg.action === 'process-channel-message') {\n                this.processChannelMessage(msg);\n                return true;\n            }\n            return false;\n        };\n        this.endpointMap = new Map();\n        this.latestEndpointIdByChannelId = new Map();\n        wire.registerMessageHandler(this.onmessage.bind(this));\n    }\n    async processChannelMessage(msg) {\n        const { senderIdentity, providerIdentity, action, ackToSender, payload, intendedTargetIdentity } = msg.payload;\n        const key = intendedTargetIdentity.channelId ?? // The recipient is a provider\n            intendedTargetIdentity.endpointId ?? // The recipient is a client\n            this.latestEndpointIdByChannelId.get(providerIdentity.channelId); // No endpointId was passed, make best attempt\n        const handler = this.endpointMap.get(key);\n        if (!handler) {\n            ackToSender.payload.success = false;\n            ackToSender.payload.reason = `Client connection with identity uuid: ${this.wire.me.uuid} / name: ${this.wire.me.name} / endpointId: ${key} no longer connected.`;\n            return this.wire.sendRaw(ackToSender);\n        }\n        try {\n            const res = await handler(action, payload, senderIdentity);\n            ackToSender.payload.payload = ackToSender.payload.payload || {};\n            ackToSender.payload.payload.result = res;\n            return this.wire.sendRaw(ackToSender);\n        }\n        catch (e) {\n            ackToSender.payload.success = false;\n            ackToSender.payload.reason = e.message;\n            return this.wire.sendRaw(ackToSender);\n        }\n    }\n    addEndpoint(handler, channelId, endpointId) {\n        this.endpointMap.set(endpointId, handler);\n        // Providers have the same endpointId and channelId.\n        // This is only used when clients are receiving messages from providers, so we shouldn't save provider endpointId here.\n        if (channelId !== endpointId) {\n            this.latestEndpointIdByChannelId.set(channelId, endpointId);\n        }\n    }\n    removeEndpoint(channelId, endpointId) {\n        this.endpointMap.delete(endpointId);\n        if (this.latestEndpointIdByChannelId.get(channelId) === endpointId) {\n            this.latestEndpointIdByChannelId.delete(channelId);\n        }\n    }\n    checkForPreviousClientConnection(channelId) {\n        const endpointIdFromPreviousConnection = this.latestEndpointIdByChannelId.get(channelId);\n        if (endpointIdFromPreviousConnection) {\n            // Not convinced by this way of doing things, but pushing up for now.\n            client_1$1.ChannelClient.closeChannelByEndpointId(endpointIdFromPreviousConnection);\n            // eslint-disable-next-line no-console\n            console.warn('You have created a second connection to an older provider. First connection has been removed from the clientMap');\n            // eslint-disable-next-line no-console\n            console.warn('If the provider calls publish(), you may receive multiple messages.');\n        }\n    }\n}\nmessageReceiver.MessageReceiver = MessageReceiver;\n\nvar protocolManager = {};\n\nObject.defineProperty(protocolManager, \"__esModule\", { value: true });\nprotocolManager.ProtocolManager = void 0;\n/*\nThis should be agnostic of any actual openfin code to be unit testable.\nDependencies on the actual srategies should be handled in ConnectionManager\n*/\nclass ProtocolManager {\n    // eslint-disable-next-line no-useless-constructor\n    constructor(ProtocolsInPreferenceOrder) {\n        this.ProtocolsInPreferenceOrder = ProtocolsInPreferenceOrder;\n        this.DefaultClientProtocols = ['classic'];\n        this.DefaultProviderProtocols = ['classic'];\n        this.getClientProtocols = (protocols) => {\n            const supported = protocols\n                ? this.ProtocolsInPreferenceOrder.filter((x) => protocols.includes(x))\n                : this.DefaultClientProtocols;\n            if (!supported.length) {\n                throw new Error(`No valid protocols were passed in. Accepted values are: ${this.ProtocolsInPreferenceOrder.join(', ')}.`);\n            }\n            return supported;\n        };\n        this.getProviderProtocols = (protocols) => {\n            const supported = protocols\n                ? this.ProtocolsInPreferenceOrder.filter((x) => protocols.includes(x))\n                : this.DefaultProviderProtocols;\n            if (!supported.length) {\n                throw new Error(`No valid protocols were passed in. Accepted values are: ${this.ProtocolsInPreferenceOrder.join(', ')}.`);\n            }\n            return supported;\n        };\n        this.getCompatibleProtocols = (providerProtocols, clientOffer) => {\n            const supported = clientOffer.supportedProtocols.filter((clientProtocol) => providerProtocols.some((providerProtocol) => providerProtocol.type === clientProtocol.type &&\n                clientProtocol.version >= providerProtocol.minimumVersion &&\n                providerProtocol.version >= (clientProtocol.minimumVersion ?? 0)));\n            return supported.slice(0, clientOffer.maxProtocols);\n        };\n    }\n}\nprotocolManager.ProtocolManager = ProtocolManager;\n\nvar strategy = {};\n\nObject.defineProperty(strategy, \"__esModule\", { value: true });\nclass CombinedStrategy {\n    // Making this a static method because the constructor can't be typed.\n    // Otherwise it will error when calling addEndpoint but I'd rather the whole instance be typed as never.\n    static combine(a, b) {\n        return new CombinedStrategy(a, b);\n    }\n    // eslint-disable-next-line no-useless-constructor\n    constructor(primary, secondary) {\n        this.primary = primary;\n        this.secondary = secondary;\n    }\n    onEndpointDisconnect(endpointId, listener) {\n        this.primary.onEndpointDisconnect(endpointId, () => {\n            if (!this.secondary.isEndpointConnected(endpointId)) {\n                listener();\n            }\n        });\n        this.secondary.onEndpointDisconnect(endpointId, () => {\n            if (!this.primary.isEndpointConnected(endpointId)) {\n                listener();\n            }\n        });\n    }\n    isValidEndpointPayload(payload) {\n        return this.primary.isValidEndpointPayload(payload) || this.secondary.isValidEndpointPayload(payload);\n    }\n    async closeEndpoint(endpointId) {\n        await this.primary.closeEndpoint(endpointId);\n        await this.secondary.closeEndpoint(endpointId);\n    }\n    isEndpointConnected(endpoint) {\n        return this.primary.isEndpointConnected(endpoint) || this.secondary.isEndpointConnected(endpoint);\n    }\n    async addEndpoint(endpoint, payload) {\n        if (this.primary.isValidEndpointPayload(payload)) {\n            await this.primary.addEndpoint(endpoint, payload);\n        }\n        if (this.secondary.isValidEndpointPayload(payload)) {\n            await this.secondary.addEndpoint(endpoint, payload);\n        }\n    }\n    receive(listener) {\n        this.primary.receive(listener);\n        this.secondary.receive(listener);\n    }\n    send(endpointId, action, payload) {\n        if (this.primary.isEndpointConnected(endpointId)) {\n            return this.primary.send(endpointId, action, payload);\n        }\n        return this.secondary.send(endpointId, action, payload);\n    }\n    async close() {\n        await Promise.all([this.primary.close(), this.secondary.close()]);\n    }\n}\nstrategy.default = CombinedStrategy;\n\nvar __classPrivateFieldSet$5 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar __classPrivateFieldGet$7 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar __importDefault$1 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nvar _ConnectionManager_messageReceiver, _ConnectionManager_rtcConnectionManager;\nObject.defineProperty(connectionManager, \"__esModule\", { value: true });\nconnectionManager.ConnectionManager = void 0;\nconst exhaustive_1 = exhaustive;\nconst base_1$f = base;\nconst strategy_1 = strategy$3;\nconst strategy_2 = strategy$2;\nconst ice_manager_1 = iceManager;\nconst provider_1$1 = provider;\nconst message_receiver_1 = messageReceiver;\nconst protocol_manager_1 = protocolManager;\nconst strategy_3 = __importDefault$1(strategy);\nclass ConnectionManager extends base_1$f.Base {\n    static getProtocolOptionsFromStrings(protocols) {\n        return protocols.map((protocol) => {\n            switch (protocol) {\n                case 'rtc':\n                    return strategy_2.RTCInfo;\n                case 'classic':\n                    return strategy_1.ClassicInfo;\n                default:\n                    return (0, exhaustive_1.exhaustiveCheck)(protocol, ['rtc', 'classic']);\n            }\n        });\n    }\n    constructor(wire) {\n        super(wire);\n        _ConnectionManager_messageReceiver.set(this, void 0);\n        _ConnectionManager_rtcConnectionManager.set(this, void 0);\n        this.removeChannelFromProviderMap = (channelId) => {\n            this.providerMap.delete(channelId);\n        };\n        this.onmessage = (msg) => {\n            if (msg.action === 'process-channel-connection') {\n                this.processChannelConnection(msg);\n                return true;\n            }\n            return false;\n        };\n        this.providerMap = new Map();\n        this.protocolManager = new protocol_manager_1.ProtocolManager(this.wire.environment.type === 'node' ? ['classic'] : ['rtc', 'classic']);\n        __classPrivateFieldSet$5(this, _ConnectionManager_messageReceiver, new message_receiver_1.MessageReceiver(wire), \"f\");\n        __classPrivateFieldSet$5(this, _ConnectionManager_rtcConnectionManager, new ice_manager_1.RTCICEManager(wire), \"f\");\n        wire.registerMessageHandler(this.onmessage.bind(this));\n    }\n    createProvider(options, providerIdentity) {\n        const opts = Object.assign(this.wire.environment.getDefaultChannelOptions().create, options || {});\n        const protocols = this.protocolManager.getProviderProtocols(opts?.protocols);\n        const createSingleStrategy = (stratType) => {\n            switch (stratType) {\n                case 'rtc':\n                    return new strategy_2.RTCStrategy();\n                case 'classic':\n                    return new strategy_1.ClassicStrategy(this.wire, __classPrivateFieldGet$7(this, _ConnectionManager_messageReceiver, \"f\"), \n                    // Providers do not have an endpointId, use channelId as endpointId in the strategy.\n                    providerIdentity.channelId, providerIdentity);\n                default:\n                    return (0, exhaustive_1.exhaustiveCheck)(stratType, ['rtc', 'classic']);\n            }\n        };\n        const strategies = protocols.map(createSingleStrategy);\n        let strategy;\n        if (strategies.length === 2) {\n            const [a, b] = strategies;\n            strategy = strategy_3.default.combine(a, b);\n        }\n        else if (strategies.length === 1) {\n            [strategy] = strategies;\n        }\n        else {\n            // Should be impossible.\n            throw new Error('failed to combine strategies');\n        }\n        const channel = new provider_1$1.ChannelProvider(providerIdentity, () => provider_1$1.ChannelProvider.wireClose(this.wire, providerIdentity.channelName), strategy);\n        const key = providerIdentity.channelId;\n        this.providerMap.set(key, {\n            provider: channel,\n            strategy,\n            supportedProtocols: ConnectionManager.getProtocolOptionsFromStrings(protocols)\n        });\n        provider_1$1.ChannelProvider.setProviderRemoval(channel, this.removeChannelFromProviderMap.bind(this));\n        return channel;\n    }\n    async createClientOffer(options) {\n        const protocols = this.protocolManager.getClientProtocols(options?.protocols);\n        let rtcPacket;\n        const supportedProtocols = await Promise.all(protocols.map(async (type) => {\n            switch (type) {\n                case 'rtc': {\n                    const { rtcClient, channels, offer, rtcConnectionId, channelsOpened } = await __classPrivateFieldGet$7(this, _ConnectionManager_rtcConnectionManager, \"f\").startClientOffer();\n                    rtcPacket = { rtcClient, channels, channelsOpened };\n                    return {\n                        type: 'rtc',\n                        version: strategy_2.RTCInfo.version,\n                        payload: { offer, rtcConnectionId }\n                    };\n                }\n                case 'classic':\n                    return { type: 'classic', version: strategy_1.ClassicInfo.version };\n                default:\n                    return (0, exhaustive_1.exhaustiveCheck)(type, ['rtc', 'classic']);\n            }\n        }));\n        return {\n            offer: {\n                supportedProtocols,\n                maxProtocols: 2\n            },\n            rtc: rtcPacket\n        };\n    }\n    async createClientStrategy(rtcPacket, routingInfo) {\n        if (!routingInfo.endpointId) {\n            routingInfo.endpointId = this.wire.environment.getNextMessageId();\n            // For New Clients connecting to Old Providers. To prevent multi-dispatching and publishing, we delete previously-connected\n            // clients that are in the same context as the newly-connected client.\n            __classPrivateFieldGet$7(this, _ConnectionManager_messageReceiver, \"f\").checkForPreviousClientConnection(routingInfo.channelId);\n        }\n        const answer = routingInfo.answer ?? {\n            supportedProtocols: [{ type: 'classic', version: 1 }]\n        };\n        const createStrategyFromAnswer = async (protocol) => {\n            if (protocol.type === 'rtc' && rtcPacket) {\n                await __classPrivateFieldGet$7(this, _ConnectionManager_rtcConnectionManager, \"f\").finishClientOffer(rtcPacket.rtcClient, protocol.payload.answer, rtcPacket.channelsOpened);\n                return new strategy_2.RTCStrategy();\n            }\n            if (protocol.type === 'classic') {\n                return new strategy_1.ClassicStrategy(this.wire, __classPrivateFieldGet$7(this, _ConnectionManager_messageReceiver, \"f\"), routingInfo.endpointId, routingInfo);\n            }\n            return null;\n        };\n        const allProtocols = (await Promise.all(answer.supportedProtocols.map(createStrategyFromAnswer))).filter((x) => x !== null);\n        // Clean up logic if provider didn't support rtc.\n        if (rtcPacket && !allProtocols.some((x) => x instanceof strategy_2.RTCStrategy)) {\n            if (rtcPacket) {\n                rtcPacket.rtcClient.close();\n            }\n        }\n        let strategy;\n        if (allProtocols.length >= 2) {\n            strategy = strategy_3.default.combine(allProtocols[0], allProtocols[1]);\n        }\n        else if (allProtocols.length) {\n            [strategy] = allProtocols;\n        }\n        else {\n            // Should be impossible.\n            throw new Error('No compatible protocols');\n        }\n        // as casting rtcPacket because we won't have an rtcStrategy if rtcPacket is undefined;\n        const endpointPayload = { endpointIdentity: routingInfo, rtc: rtcPacket };\n        strategy.addEndpoint(routingInfo.channelId, endpointPayload);\n        return strategy;\n    }\n    async processChannelConnection(msg) {\n        const { clientIdentity, providerIdentity, ackToSender, payload, offer: clientOffer } = msg.payload;\n        if (!clientIdentity.endpointId) {\n            // Should be polyfilled by core but not in cases of node connecting to an old runtime.\n            clientIdentity.endpointId = this.wire.environment.getNextMessageId();\n            clientIdentity.isLocalEndpointId = true;\n        }\n        else {\n            clientIdentity.isLocalEndpointId = false;\n        }\n        const key = providerIdentity.channelId;\n        const bus = this.providerMap.get(key);\n        if (!bus) {\n            ackToSender.payload.success = false;\n            ackToSender.payload.reason = `Channel \"${providerIdentity.channelName}\" has been destroyed.`;\n            return this.wire.sendRaw(ackToSender);\n        }\n        const { provider, strategy, supportedProtocols } = bus;\n        try {\n            if (!(provider instanceof provider_1$1.ChannelProvider)) {\n                throw Error('Cannot connect to a channel client');\n            }\n            const offer = clientOffer ?? {\n                supportedProtocols: [{ type: 'classic', version: 1 }],\n                maxProtocols: 1\n            };\n            const overlappingProtocols = this.protocolManager.getCompatibleProtocols(supportedProtocols, offer);\n            if (!overlappingProtocols.length) {\n                throw new Error('This provider does not support any of the offered protocols.');\n            }\n            const res = await provider.processConnection(clientIdentity, payload);\n            ackToSender.payload.payload = ackToSender.payload.payload || {};\n            // Loop through all supported protocols and accumulate them into the answer\n            // addEndpoint is tricky but we need to wait for channel resolution before adding the endpoint.\n            let clientAnswer = {\n                supportedProtocols: [],\n                endpointPayloadPromise: Promise.resolve({ endpointIdentity: clientIdentity })\n            };\n            clientAnswer = await overlappingProtocols.reduce(async (accumP, protocolToUse) => {\n                const answer = await accumP;\n                if (protocolToUse.type === 'rtc') {\n                    const { answer: rtcAnswer, rtcClient, channels } = await __classPrivateFieldGet$7(this, _ConnectionManager_rtcConnectionManager, \"f\").createProviderAnswer(protocolToUse.payload.rtcConnectionId, protocolToUse.payload.offer);\n                    answer.supportedProtocols.push({\n                        type: 'rtc',\n                        version: strategy_2.RTCInfo.version,\n                        payload: {\n                            answer: rtcAnswer\n                        }\n                    });\n                    answer.endpointPayloadPromise = answer.endpointPayloadPromise.then((endpointPayload) => channels.then((resolvedChannels) => {\n                        return {\n                            ...endpointPayload,\n                            rtc: {\n                                rtcClient,\n                                channels: resolvedChannels\n                            }\n                        };\n                    }));\n                }\n                else {\n                    answer.supportedProtocols.push({ type: 'classic', version: strategy_1.ClassicInfo.version });\n                }\n                return answer;\n            }, Promise.resolve(clientAnswer));\n            // Need to as cast here.\n            clientAnswer.endpointPayloadPromise.then((endpointPayload) => strategy.addEndpoint(clientIdentity.endpointId, endpointPayload));\n            ackToSender.payload.payload.result = res;\n            ackToSender.payload.payload.answer = clientAnswer;\n            return this.wire.sendRaw(ackToSender);\n        }\n        catch (e) {\n            ackToSender.payload.success = false;\n            ackToSender.payload.reason = e.message;\n            return this.wire.sendRaw(ackToSender);\n        }\n    }\n}\nconnectionManager.ConnectionManager = ConnectionManager;\n_ConnectionManager_messageReceiver = new WeakMap(), _ConnectionManager_rtcConnectionManager = new WeakMap();\n\n/**\n * Entry points for the `Channel` subset of the `InterApplicationBus` API (`fin.InterApplicationBus.Channel`).\n *\n * * {@link Channel} contains static members of the `Channel` API, accessible through `fin.InterApplicationBus.Channel`.\n * * {@link OpenFin.ChannelClient} describes a client of a channel, e.g. as returned by `fin.InterApplicationBus.Channel.connect`.\n * * {@link OpenFin.ChannelProvider} describes a provider of a channel, e.g. as returned by `fin.InterApplicationBus.Channel.create`.\n *\n * @packageDocumentation\n */\nvar __classPrivateFieldSet$4 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar __classPrivateFieldGet$6 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar _Channel_connectionManager, _Channel_internalEmitter, _Channel_readyToConnect;\nObject.defineProperty(channel$1, \"__esModule\", { value: true });\nchannel$1.Channel = void 0;\n/* eslint-disable no-console */\nconst events_1$5 = require$$0;\nconst lazy_1$1 = lazy;\nconst base_1$e = base;\nconst client_1 = client;\nconst connection_manager_1 = connectionManager;\nconst provider_1 = provider;\nfunction retryDelay(count) {\n    const interval = 500; // base delay\n    const steps = 10; // How many retries to do before incrementing the delay\n    const base = 2; // How much to multiply the previous delay by\n    const max = 30000; // max delay\n    const step = Math.floor(count / steps);\n    const delay = Math.min(max, interval * base ** step);\n    return new Promise((resolve) => {\n        setTimeout(() => {\n            resolve(false);\n        }, delay);\n    });\n}\n/**\n * The Channel API allows an OpenFin application to create a channel as a {@link ChannelProvider ChannelProvider},\n * or connect to a channel as a {@link ChannelClient ChannelClient}.\n * @remarks The \"handshake\" between the communication partners is\n * simplified when using a channel.  A request to connect to a channel as a client will return a promise that resolves if/when the channel has been created. Both the\n * provider and client can dispatch actions that have been registered on their opposites, and dispatch returns a promise that resolves with a payload from the other\n * communication participant. There can be only one provider per channel, but many clients.  Version `9.61.35.*` or later is required for both communication partners.\n *\n * Asynchronous Methods:\n *  * {@link Channel.create create(channelName, options)}\n *  * {@link Channel.connect connect(channelName, options)}\n *  * {@link Channel.onChannelConnect onChannelConnect(listener)}\n *  * {@link Channel.onChannelDisconnect onChannelDisconnect(listener)}\n */\nclass Channel extends base_1$e.EmitterBase {\n    /**\n     * @internal\n     */\n    constructor(wire) {\n        super(wire, 'channel');\n        _Channel_connectionManager.set(this, void 0);\n        _Channel_internalEmitter.set(this, new events_1$5.EventEmitter());\n        // OpenFin API has not been injected at construction time, *must* wait for API to be ready.\n        _Channel_readyToConnect.set(this, new lazy_1$1.AsyncRetryableLazy(async () => {\n            await Promise.all([\n                this.on('disconnected', (eventPayload) => {\n                    client_1.ChannelClient.handleProviderDisconnect(eventPayload);\n                }),\n                this.on('connected', (...args) => {\n                    __classPrivateFieldGet$6(this, _Channel_internalEmitter, \"f\").emit('connected', ...args);\n                })\n            ]).catch(() => new Error('error setting up channel connection listeners'));\n        }));\n        __classPrivateFieldSet$4(this, _Channel_connectionManager, new connection_manager_1.ConnectionManager(wire), \"f\");\n    }\n    /**\n     *\n     * @internal\n     */\n    async getAllChannels() {\n        return this.wire.sendAction('get-all-channels').then(({ payload }) => payload.data);\n    }\n    /**\n     * Listens for channel connections.\n     *\n     * @param listener - callback to execute.\n     *\n     * @example\n     *\n     * ```js\n     * const listener = (channelPayload) => console.log(channelPayload); // see return value below\n     *\n     * fin.InterApplicationBus.Channel.onChannelConnect(listener);\n     *\n     * // example shape\n     * {\n     *     \"topic\": \"channel\",\n     *     \"type\": \"connected\",\n     *     \"uuid\": \"OpenfinPOC\",\n     *     \"name\": \"OpenfinPOC\",\n     *     \"channelName\": \"counter\",\n     *     \"channelId\": \"OpenfinPOC/OpenfinPOC/counter\"\n     * }\n     *\n     * ```\n     */\n    async onChannelConnect(listener) {\n        await this.on('connected', listener);\n    }\n    /**\n     * Listen for channel disconnections.\n     *\n     * @param listener - callback to execute.\n     *\n     * @example\n     *\n     * ```js\n     * const listener = (channelPayload) => console.log(channelPayload); // see return value below\n     *\n     * fin.InterApplicationBus.Channel.onChannelDisconnect(listener);\n     *\n     * // example shape\n     * {\n     *     \"topic\": \"channel\",\n     *     \"type\": \"disconnected\",\n     *     \"uuid\": \"OpenfinPOC\",\n     *     \"name\": \"OpenfinPOC\",\n     *     \"channelName\": \"counter\",\n     *     \"channelId\": \"OpenfinPOC/OpenfinPOC/counter\"\n     * }\n     *\n     * ```\n     */\n    async onChannelDisconnect(listener) {\n        await this.on('disconnected', listener);\n    }\n    async safeConnect(channelName, shouldWait, connectPayload) {\n        const retryInfo = { count: 0 };\n        /* eslint-disable no-await-in-loop, no-constant-condition */\n        do {\n            // setup a listener and a connected promise to await in case we connect before the channel is ready\n            let connectedListener = () => undefined;\n            const connectedPromise = new Promise((resolve) => {\n                connectedListener = (payload) => {\n                    if (channelName === payload.channelName) {\n                        resolve(true);\n                    }\n                };\n                __classPrivateFieldGet$6(this, _Channel_internalEmitter, \"f\").on('connected', connectedListener);\n            });\n            try {\n                if (retryInfo.count > 0) {\n                    // Wait before retrying\n                    // Delay returns false connectedPromise returns true so we can know if a retry is due to connected event\n                    retryInfo.gotConnectedEvent = await Promise.race([retryDelay(retryInfo.count), connectedPromise]);\n                    const result = await this.wire.sendAction('connect-to-channel', { ...connectPayload, retryInfo });\n                    // log only if there was a retry\n                    console.log(`Successfully connected to channelName: ${channelName}`);\n                    return result.payload.data;\n                }\n                // Send retryInfo to the core for debug log inclusion\n                const sentMessagePromise = this.wire.sendAction('connect-to-channel', connectPayload);\n                // Save messageId from the first connection attempt\n                retryInfo.originalMessageId = sentMessagePromise.messageId;\n                const result = await sentMessagePromise;\n                return result.payload.data;\n            }\n            catch (error) {\n                if (!error.message.includes('internal-nack')) {\n                    // Not an internal nack, break the loop\n                    throw error;\n                }\n                if (shouldWait && retryInfo.count === 0) {\n                    // start waiting on the next iteration, warn the user\n                    console.warn(`No channel found for channelName: ${channelName}. Waiting for connection...`);\n                }\n            }\n            finally {\n                retryInfo.count += 1;\n                // in case of other errors, remove our listener\n                __classPrivateFieldGet$6(this, _Channel_internalEmitter, \"f\").removeListener('connected', connectedListener);\n            }\n        } while (shouldWait); // If we're waiting we retry the above loop\n        // Should wait was false, no channel was found.\n        throw new Error(`No channel found for channelName: ${channelName}.`);\n        /* eslint-enable no-await-in-loop, no-constant-condition */\n    }\n    /**\n     * Connect to a channel. If you wish to send a payload to the provider, add a payload property to the options argument.\n     * EXPERIMENTAL: pass { protocols: ['rtc'] } as options to opt-in to High Throughput Channels.\n     *\n     * @param channelName - Name of the target channel.\n     * @param options - Connection options.\n     * @returns Returns a promise that resolves with an instance of {@link ChannelClient ChannelClient}.\n     *\n     * @remarks The connection request will be routed to the channelProvider if/when the channel is created.  If the connect\n     * request is sent prior to creation, the promise will not resolve or reject until the channel is created by a channelProvider\n     * (whether or not to wait for creation is configurable in the connectOptions).\n     *\n     * The connect call returns a promise that will resolve with a channelClient bus if accepted by the channelProvider, or reject if\n     * the channelProvider throws an error to reject the connection. This bus can communicate with the Provider, but not to other\n     * clients on the channel. Using the bus, the channelClient can register actions and middleware. Channel lifecycle can also be\n     * handled with an onDisconnection listener.\n     *\n     * @example\n     *\n     * ```js\n     * async function makeClient(channelName) {\n     *    // A payload can be sent along with channel connection requests to help with authentication\n     *    const connectPayload = { payload: 'token' };\n     *\n     *    // If the channel has been created this request will be sent to the provider.  If not, the\n     *    // promise will not be resolved or rejected until the channel has been created.\n     *    const clientBus = await fin.InterApplicationBus.Channel.connect(channelName, connectPayload);\n     *\n     *    clientBus.onDisconnection(channelInfo => {\n     *        // handle the channel lifecycle here - we can connect again which will return a promise\n     *        // that will resolve if/when the channel is re-created.\n     *        makeClient(channelInfo.channelName);\n     *    })\n     *\n     *    clientBus.register('topic', (payload, identity) => {\n     *        // register a callback for a topic to which the channel provider can dispatch an action\n     *        console.log('Action dispatched by provider: ', JSON.stringify(identity));\n     *        console.log('Payload sent in dispatch: ', JSON.stringify(payload));\n     *        return {\n     *            echo: payload\n     *        };\n     *    });\n     * }\n     *\n     * makeClient('channelName')\n     * .then(() => console.log('Connected'))\n     * .catch(console.error);\n     * ```\n     */\n    async connect(channelName, options = {}) {\n        // Make sure we don't connect before listeners are set up\n        // This also errors if we're not in OpenFin, ensuring we don't run unnecessary code\n        await __classPrivateFieldGet$6(this, _Channel_readyToConnect, \"f\").getValue();\n        if (!channelName || typeof channelName !== 'string') {\n            throw new Error('Please provide a channelName string to connect to a channel.');\n        }\n        const opts = { wait: true, ...this.wire.environment.getDefaultChannelOptions().connect, ...options };\n        const { offer, rtc: rtcPacket } = await __classPrivateFieldGet$6(this, _Channel_connectionManager, \"f\").createClientOffer(opts);\n        let connectionUrl;\n        if (this.fin.me.isFrame || this.fin.me.isView || this.fin.me.isWindow) {\n            connectionUrl = (await this.fin.me.getInfo()).url;\n        }\n        const connectPayload = {\n            channelName,\n            ...opts,\n            offer,\n            connectionUrl\n        };\n        const routingInfo = await this.safeConnect(channelName, opts.wait, connectPayload);\n        const strategy = await __classPrivateFieldGet$6(this, _Channel_connectionManager, \"f\").createClientStrategy(rtcPacket, routingInfo);\n        const channel = new client_1.ChannelClient(routingInfo, () => client_1.ChannelClient.wireClose(this.wire, routingInfo, routingInfo.endpointId), strategy);\n        // It is the client's responsibility to handle endpoint disconnection to the provider.\n        // If the endpoint dies, the client will force a disconnection through the core.\n        // The provider does not care about endpoint disconnection.\n        strategy.onEndpointDisconnect(routingInfo.channelId, async () => {\n            try {\n                await channel.sendDisconnectAction();\n            }\n            catch (error) {\n                console.warn(`Something went wrong during disconnect for client with uuid: ${routingInfo.uuid} / name: ${routingInfo.name} / endpointId: ${routingInfo.endpointId}.`);\n            }\n            finally {\n                client_1.ChannelClient.handleProviderDisconnect(routingInfo);\n            }\n        });\n        return channel;\n    }\n    /**\n     * Create a new channel.\n     * You must provide a unique channelName. If a channelName is not provided, or it is not unique, the creation will fail.\n     * EXPERIMENTAL: pass { protocols: ['rtc'] } as options to opt-in to High Throughput Channels.\n     *\n     * @param channelName - Name of the channel to be created.\n     * @param options - Creation options.\n     * @returns Returns a promise that resolves with an instance of {@link ChannelProvider ChannelProvider}.\n     *\n     * @remarks If successful, the create method returns a promise that resolves to an instance of the channelProvider bus. The caller\n     * then becomes the “channel provider” and can use the channelProvider bus to register actions and middleware.\n     *\n     * The caller can also set an onConnection and/or onDisconnection listener that will execute on any new channel\n     * connection/disconnection attempt from a channel client. To reject a connection, simply throw an error in the\n     * onConnection listener.  The default behavior is to accept all new connections.\n     *\n     * A map of client connections is updated automatically on client connection and disconnection and saved in the\n     * [read-only] `connections` property on the channelProvider bus.  The channel will exist until the provider\n     * destroys it or disconnects by closing or destroying the context (navigating or reloading). To setup a channel\n     * as a channelProvider, call `Channel.create` with a unique channel name. A map of client connections is updated\n     * automatically on client connection and disconnection.\n     *\n     * @example\n     *\n     * ```js\n     * (async ()=> {\n     *    // entity creates a channel and becomes the channelProvider\n     *    const providerBus = await fin.InterApplicationBus.Channel.create('channelName');\n     *\n     *    providerBus.onConnection((identity, payload) => {\n     *        // can reject a connection here by throwing an error\n     *        console.log('Client connection request identity: ', JSON.stringify(identity));\n     *        console.log('Client connection request payload: ', JSON.stringify(payload));\n     *    });\n     *\n     *    providerBus.register('topic', (payload, identity) => {\n     *        // register a callback for a 'topic' to which clients can dispatch an action\n     *        console.log('Action dispatched by client: ', JSON.stringify(identity));\n     *        console.log('Payload sent in dispatch: ', JSON.stringify(payload));\n     *        return {\n     *            echo: payload\n     *        };\n     *    });\n     * })();\n     * ```\n     */\n    async create(channelName, options) {\n        if (!channelName) {\n            throw new Error('Please provide a channelName to create a channel');\n        }\n        const { payload: { data: providerIdentity } } = await this.wire.sendAction('create-channel', { channelName });\n        const channel = __classPrivateFieldGet$6(this, _Channel_connectionManager, \"f\").createProvider(options, providerIdentity);\n        // TODO: fix typing (internal)\n        // @ts-expect-error\n        this.on('client-disconnected', (eventPayload) => {\n            if (eventPayload.channelName === channelName) {\n                provider_1.ChannelProvider.handleClientDisconnection(channel, eventPayload);\n            }\n        });\n        return channel;\n    }\n}\nchannel$1.Channel = Channel;\n_Channel_connectionManager = new WeakMap(), _Channel_internalEmitter = new WeakMap(), _Channel_readyToConnect = new WeakMap();\n\nObject.defineProperty(interappbus, \"__esModule\", { value: true });\ninterappbus.InterAppPayload = interappbus.InterApplicationBus = void 0;\n/**\n * Entry point for the OpenFin `InterApplicationBus` API (`fin.InterApplicationBus`).\n *\n * * {@link InterApplicationBus} contains static members of the `InterApplicationBus` API, accessible through `fin.InterApplicationBus`.\n *\n * @packageDocumentation\n */\nconst events_1$4 = require$$0;\nconst base_1$d = base;\nconst ref_counter_1 = refCounter;\nconst index_1$2 = channel$1;\nconst validate_1$3 = validate;\n/**\n * A messaging bus that allows for pub/sub messaging between different applications.\n *\n */\nclass InterApplicationBus extends base_1$d.Base {\n    /**\n     * @internal\n     */\n    constructor(wire) {\n        super(wire);\n        this.events = {\n            subscriberAdded: 'subscriber-added',\n            subscriberRemoved: 'subscriber-removed'\n        };\n        this.refCounter = new ref_counter_1.RefCounter();\n        this.Channel = new index_1$2.Channel(wire);\n        this.emitter = new events_1$4.EventEmitter();\n        wire.registerMessageHandler(this.onmessage.bind(this));\n        this.on = this.emitter.on.bind(this.emitter);\n        this.removeAllListeners = this.emitter.removeAllListeners.bind(this.emitter);\n    }\n    /**\n     * Publishes a message to all applications running on OpenFin Runtime that\n     * are subscribed to the specified topic.\n     * @param topic The topic on which the message is sent\n     * @param message The message to be published. Can be either a primitive\n     * data type (string, number, or boolean) or composite data type (object, array)\n     * that is composed of other primitive or composite data types\n     *\n     * @example\n     * ```js\n     * fin.InterApplicationBus.publish('topic', 'hello').then(() => console.log('Published')).catch(err => console.log(err));\n     * ```\n     */\n    async publish(topic, message) {\n        await this.wire.sendAction('publish-message', {\n            topic,\n            message,\n            sourceWindowName: this.me.name\n        });\n    }\n    /**\n     * Sends a message to a specific application on a specific topic.\n     * @param destination The identity of the application to which the message is sent\n     * @param topic The topic on which the message is sent\n     * @param message The message to be sent. Can be either a primitive data\n     * type (string, number, or boolean) or composite data type (object, array) that\n     * is composed of other primitive or composite data types\n     *\n     * @example\n     * ```js\n     * fin.InterApplicationBus.send(fin.me, 'topic', 'Hello there!').then(() => console.log('Message sent')).catch(err => console.log(err));\n     * ```\n     */\n    async send(destination, topic, message) {\n        const errorMsg = (0, validate_1$3.validateIdentity)(destination);\n        if (errorMsg) {\n            throw new Error(errorMsg);\n        }\n        await this.wire.sendAction('send-message', {\n            destinationUuid: destination.uuid,\n            destinationWindowName: destination.name,\n            topic,\n            message,\n            sourceWindowName: this.me.name\n        });\n    }\n    /**\n     * Subscribes to messages from the specified application on the specified topic.\n     * @param source This object is described in the Identity in the typedef\n     * @param topic The topic on which the message is sent\n     * @param listener A function that is called when a message has\n     * been received. It is passed the message, uuid and name of the sending application.\n     * The message can be either a primitive data type (string, number, or boolean) or\n     * composite data type (object, array) that is composed of other primitive or composite\n     * data types\n     *\n     * @example\n     * ```js\n     * // subscribe to a specified application\n     * fin.InterApplicationBus.subscribe(fin.me, 'topic', sub_msg => console.log(sub_msg)).then(() => console.log('Subscribed to the specified application')).catch(err => console.log(err));\n     *\n     * // subscribe to wildcard\n     * fin.InterApplicationBus.subscribe({ uuid: '*' }, 'topic', sub_msg => console.log(sub_msg)).then(() => console.log('Subscribed to *')).catch(err => console.log(err));\n     * ```\n     */\n    subscribe(source, topic, listener) {\n        const subKey = this.createSubscriptionKey(source.uuid, source.name || '*', topic);\n        const sendSubscription = async () => {\n            await this.wire.sendAction('subscribe', {\n                sourceUuid: source.uuid,\n                sourceWindowName: source.name || '*',\n                topic,\n                destinationWindowName: this.me.name\n            });\n        };\n        const alreadySubscribed = () => {\n            return Promise.resolve();\n        };\n        this.emitter.on(subKey, listener);\n        return this.refCounter.actOnFirst(subKey, sendSubscription, alreadySubscribed);\n    }\n    /**\n     * Unsubscribes to messages from the specified application on the specified topic.\n     *\n     * @remarks If you are listening to all apps on a topic, (i.e you passed `{ uuid:'*' }` to the subscribe function)\n     * then you need to pass `{ uuid:'*' }` to unsubscribe as well. If you are listening to a specific application,\n     * (i.e you passed `{ uuid:'some_app' }` to the subscribe function) then you need to provide the same identifier to\n     * unsubscribe, unsubscribing to `*` on that same topic will not unhook your initial listener otherwise.\n     *\n     * @param source This object is described in the Identity in the typedef\n     * @param topic The topic on which the message is sent\n     * @param listener A callback previously registered with subscribe()\n     *\n     * @example\n     * ```js\n     * const listener = console.log;\n     *\n     * // If any application publishes a message on topic `foo`, our listener will be called.\n     * await fin.InterApplicationBus.subscribe({ uuid:'*' }, 'foo', listener)\n     *\n     * // When you want to unsubscribe, you need to specify the uuid of the app you'd like to\n     * // unsubscribe from (or `*`) and provide the same function you gave the subscribe function\n     * await fin.InterApplicationBus.unsubscribe({ uuid:'*' }, 'foo', listener)\n     * ```\n     */\n    unsubscribe(source, topic, listener) {\n        const sourceWindowName = source.name || '*';\n        const subKey = this.createSubscriptionKey(source.uuid, sourceWindowName, topic);\n        const sendUnsubscription = async () => {\n            await this.wire.sendAction('unsubscribe', {\n                sourceUuid: source.uuid,\n                sourceWindowName,\n                topic,\n                destinationWindowName: this.me.name\n            });\n        };\n        const dontSendUnsubscription = () => {\n            return new Promise((r) => r).then(() => undefined);\n        };\n        this.emitter.removeListener(subKey, listener);\n        return this.refCounter.actOnLast(subKey, sendUnsubscription, dontSendUnsubscription);\n    }\n    processMessage(message) {\n        const { payload: { message: payloadMessage, sourceWindowName, sourceUuid, topic } } = message;\n        const keys = [\n            this.createSubscriptionKey(sourceUuid, sourceWindowName, topic),\n            this.createSubscriptionKey(sourceUuid, '*', topic),\n            this.createSubscriptionKey('*', '*', topic)\n        ];\n        const idOfSender = { uuid: sourceUuid, name: sourceWindowName };\n        keys.forEach((key) => {\n            this.emitter.emit(key, payloadMessage, idOfSender);\n        });\n    }\n    emitSubscriverEvent(type, message) {\n        const { payload: { targetName: name, uuid, topic } } = message;\n        const payload = { name, uuid, topic };\n        this.emitter.emit(type, payload);\n    }\n    // eslint-disable-next-line class-methods-use-this\n    createSubscriptionKey(uuid, name, topic) {\n        const n = name || '*';\n        if (!(uuid && n && topic)) {\n            throw new Error('Missing uuid, name, or topic string');\n        }\n        return createKey(uuid, n, topic);\n    }\n    onmessage(message) {\n        const { action } = message;\n        switch (action) {\n            case 'process-message':\n                this.processMessage(message);\n                break;\n            case this.events.subscriberAdded:\n                this.emitSubscriverEvent(this.events.subscriberAdded, message);\n                break;\n            case this.events.subscriberRemoved:\n                this.emitSubscriverEvent(this.events.subscriberRemoved, message);\n                break;\n        }\n        return true;\n    }\n}\ninterappbus.InterApplicationBus = InterApplicationBus;\n/**\n * @internal\n */\nclass InterAppPayload {\n}\ninterappbus.InterAppPayload = InterAppPayload;\nfunction createKey(...toHash) {\n    return toHash\n        .map((item) => {\n        return Buffer.from(`${item}`).toString('base64');\n    })\n        .join('/');\n}\n\nvar clipboard = {};\n\n/**\n * Entry point for the OpenFin `Clipboard` API (`fin.Clipboard`).\n *\n * * {@link Clipboard} contains static members of the `Clipboard` API, accessible through `fin.Clipboard`.\n *\n * @packageDocumentation\n */\nObject.defineProperty(clipboard, \"__esModule\", { value: true });\nclipboard.Clipboard = void 0;\nconst base_1$c = base;\n/**\n * The Clipboard API allows reading and writing to the clipboard in multiple formats.\n *\n */\nclass Clipboard extends base_1$c.Base {\n    /**\n     * Writes data into the clipboard as plain text\n     * @param writeObj The object for writing data into the clipboard\n     *\n     * @example\n     * ```js\n     * fin.Clipboard.writeText({\n     *     data: 'hello, world'\n     * }).then(() => console.log('Text On clipboard')).catch(err => console.log(err));\n     * ```\n     */\n    async writeText(writeObj) {\n        await this.wire.sendAction('clipboard-write-text', writeObj);\n    }\n    /**\n     * Read the content of the clipboard as plain text\n     * @param type Clipboard Type defaults to 'clipboard', use 'selection' for linux\n     *\n     * @example\n     * ```js\n     * fin.Clipboard.readText().then(text => console.log(text)).catch(err => console.log(err));\n     * ```\n     */\n    async readText(type) {\n        // NOTE: When we start supporting linux, we could detect the OS and choose 'selection' automatically for the user\n        const { payload } = await this.wire.sendAction('clipboard-read-text', { type });\n        return payload.data;\n    }\n    /**\n     * Writes data into the clipboard as an Image\n     * @param writeRequest The object to write an image to the clipboard\n     *\n     * @example\n     * ```js\n     * fin.Clipboard.writeImage({\n     *   // raw base64 string, or dataURL of either data:image/png or data:image/jpeg type\n     *   image: '...'\n     * }).then(() => console.log('Image written to clipboard')).catch(err => console.log(err));\n     * ```\n     */\n    async writeImage(writeRequest) {\n        await this.wire.sendAction('clipboard-write-image', writeRequest);\n    }\n    /**\n     * Read the content of the clipboard as a base64 string or a dataURL based on the input parameter 'format', defaults to 'dataURL'\n     * @param readRequest Clipboard Read Image request with formatting options\n     *\n     * @example\n     * ```js\n     * // see TS type: OpenFin.ImageFormatOptions\n     *\n     * const pngOrDataURLOrBmpOptions = {\n     *     format: 'png', // can be: 'png' | 'dataURL' | 'bmp'\n     * };\n     *\n     * const jpgOptions = {\n     *     format: 'jpg',\n     *     quality: 80 // optional, if omitted defaults to 100\n     * };\n     *\n     * fin.Clipboard.readImage(pngOrDataURLOrBmpOptions)\n     *     .then(image => console.log('Image read from clipboard as PNG, DataURL or BMP', image))\n     *     .catch(err => console.log(err));\n     *\n     * fin.Clipboard.readImage(jpgOptions)\n     *     .then(image => console.log('Image read from clipboard as JPG', image))\n     *     .catch(err => console.log(err));\n     *\n     * // defaults to {format: 'dataURL'}\n     * fin.Clipboard.readImage()\n     *     .then(image => console.log('Image read from clipboard as DataURL', image))\n     *     .catch(err => console.log(err));\n     *\n     * ```\n     */\n    async readImage(readRequest = { format: 'dataURL' }) {\n        const { payload } = await this.wire.sendAction('clipboard-read-image', readRequest);\n        return payload.data;\n    }\n    /**\n     * Writes data into the clipboard as Html\n     * @param writeObj The object for writing data into the clipboard\n     *\n     * @example\n     * ```js\n     * fin.Clipboard.writeHtml({\n     *         data: '<h1>Hello, World!</h1>'\n     * }).then(() => console.log('HTML On clipboard')).catch(err => console.log(err));\n     * ```\n     */\n    async writeHtml(writeObj) {\n        await this.wire.sendAction('clipboard-write-html', writeObj);\n    }\n    /**\n     * Read the content of the clipboard as Html\n     * @param type Clipboard Type defaults to 'clipboard', use 'selection' for linux\n     *\n     * @example\n     * ```js\n     * fin.Clipboard.readHtml().then(html => console.log(html)).catch(err => console.log(err));\n     * ```\n     */\n    async readHtml(type) {\n        const { payload } = await this.wire.sendAction('clipboard-read-html', { type });\n        return payload.data;\n    }\n    /**\n     * Writes data into the clipboard as Rtf\n     * @param writeObj The object for writing data into the clipboard\n     *\n     * @example\n     * ```js\n     * fin.Clipboard.writeRtf({\n     *         data: 'some text goes here'\n     * }).then(() => console.log('RTF On clipboard')).catch(err => console.log(err));\n     * ```\n     */\n    async writeRtf(writeObj) {\n        await this.wire.sendAction('clipboard-write-rtf', writeObj);\n    }\n    /**\n     * Read the content of the clipboard as Rtf\n     * @param type Clipboard Type defaults to 'clipboard', use 'selection' for linux\n     *\n     * @example\n     *\n     * ```js\n     * const writeObj = {\n     *     data: 'some text goes here'\n     * };\n     * async function readRtf() {\n     *     await fin.Clipboard.writeRtf(writeObj);\n     *     return await fin.Clipboard.readRtf();\n     * }\n     * readRtf().then(rtf => console.log(rtf)).catch(err => console.log(err));\n     * ```\n     */\n    async readRtf(type) {\n        const { payload } = await this.wire.sendAction('clipboard-read-rtf', { type });\n        return payload.data;\n    }\n    /**\n     * Writes data into the clipboard\n     * @param writeObj The object for writing data into the clipboard\n     *\n     * @example\n     * ```js\n     * fin.Clipboard.write({\n     *   data: {\n     *     text: 'a',\n     *     html: 'b',\n     *     rtf: 'c',\n     *     // Can be either a base64 string, or a DataURL string. If using DataURL, the\n     *     // supported formats are `data:image/png[;base64],` and `data:image/jpeg[;base64],`.\n     *     // Using other image/<format> DataURLs will throw an Error.\n     *     image: '...'\n     *   }\n     * }).then(() => console.log('write data into clipboard')).catch(err => console.log(err));\n     * ```\n     */\n    async write(writeObj) {\n        await this.wire.sendAction('clipboard-write', writeObj);\n    }\n    /**\n     * Reads available formats for the clipboard type\n     * @param type Clipboard Type defaults to 'clipboard', use 'selection' for linux\n     *\n     * @example\n     * ```js\n     * fin.Clipboard.getAvailableFormats().then(formats => console.log(formats)).catch(err => console.log(err));\n     * ```\n     */\n    async getAvailableFormats(type) {\n        const { payload } = await this.wire.sendAction('clipboard-read-formats', { type });\n        return payload.data;\n    }\n}\nclipboard.Clipboard = Clipboard;\n\nvar externalApplication = {};\n\nvar Factory$5 = {};\n\nvar Instance$4 = {};\n\nObject.defineProperty(Instance$4, \"__esModule\", { value: true });\nInstance$4.ExternalApplication = void 0;\n/* eslint-disable import/prefer-default-export */\nconst base_1$b = base;\n/**\n * An ExternalApplication object representing native language adapter connections to the runtime. Allows\n * the developer to listen to {@link OpenFin.ExternalApplicationEvents external application events}.\n * Discovery of connections is provided by {@link System.System.getAllExternalApplications getAllExternalApplications}.</a>\n *\n * Processes that can be wrapped as `ExternalApplication`s include the following:\n * - Processes which have connected to an OpenFin runtime via an adapter\n * - Processes started via `System.launchExternalApplication`\n * - Processes monitored via `System.monitorExternalProcess`\n */\nclass ExternalApplication extends base_1$b.EmitterBase {\n    /**\n     * @internal\n     */\n    constructor(wire, identity) {\n        super(wire, 'external-application', identity.uuid);\n        this.identity = identity;\n    }\n    /**\n     * Retrieves information about the external application.\n     *\n     * @example\n     * ```js\n     * async function getInfo() {\n     *     const extApp = await fin.ExternalApplication.wrap('javaApp-uuid');\n     *     return await extApp.getInfo();\n     * }\n     * getInfo().then(info => console.log(info)).catch(err => console.log(err));\n     * ```\n     */\n    getInfo() {\n        return this.wire.sendAction('get-external-application-info', this.identity).then(({ payload }) => payload.data);\n    }\n}\nInstance$4.ExternalApplication = ExternalApplication;\n\nObject.defineProperty(Factory$5, \"__esModule\", { value: true });\nFactory$5.ExternalApplicationModule = void 0;\nconst base_1$a = base;\nconst Instance_1$4 = Instance$4;\n/**\n * Static namespace for OpenFin API methods that interact with the {@link ExternalApplication} class, available under `fin.ExternalApplication`.\n */\nclass ExternalApplicationModule extends base_1$a.Base {\n    /**\n     * Asynchronously returns an External Application object that represents an external application.\n     * <br>It is possible to wrap a process that does not yet exist, (for example, to listen for startup-related events)\n     * provided its uuid is already known.\n     * @param uuid The UUID of the external application to be wrapped\n     *\n     * @example\n     * ```js\n     * fin.ExternalApplication.wrap('javaApp-uuid');\n     * .then(extApp => console.log('wrapped external application'))\n     * .catch(err => console.log(err));\n     * ```\n     */\n    wrap(uuid) {\n        this.wire.sendAction('external-application-wrap').catch((e) => {\n            // we do not want to expose this error, just continue if this analytics-only call fails\n        });\n        return Promise.resolve(new Instance_1$4.ExternalApplication(this.wire, { uuid }));\n    }\n    /**\n     * Synchronously returns an External Application object that represents an external application.\n     * <br>It is possible to wrap a process that does not yet exist, (for example, to listen for startup-related events)\n     * provided its uuid is already known.\n     * @param uuid The UUID of the external application to be wrapped\n     *\n     * @example\n     * ```js\n     * const extApp = fin.ExternalApplication.wrapSync('javaApp-uuid');\n     * const info = await extApp.getInfo();\n     * console.log(info);\n     * ```\n     */\n    wrapSync(uuid) {\n        this.wire.sendAction('external-application-wrap-sync').catch((e) => {\n            // we do not want to expose this error, just continue if this analytics-only call fails\n        });\n        return new Instance_1$4.ExternalApplication(this.wire, { uuid });\n    }\n}\nFactory$5.ExternalApplicationModule = ExternalApplicationModule;\n\n(function (exports) {\n\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t    }\n\t    Object.defineProperty(o, k2, desc);\n\t}) : (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    o[k2] = m[k];\n\t}));\n\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t};\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t/**\n\t * Entry points for the OpenFin `ExternalApplication` API (`fin.ExternalApplication`).\n\t *\n\t * * {@link ExternalApplicationModule} contains static members of the `ExternalApplication` type, accessible through `fin.ExternalApplication`.\n\t * * {@link ExternalApplication} describes an instance of an OpenFin ExternalApplication, e.g. as returned by `fin.ExternalApplication.getCurrent`.\n\t *\n\t * These are separate code entities, and are documented separately.  In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/32.114.76.10/index.html),\n\t * both of these were documented on the same page.\n\t *\n\t * @packageDocumentation\n\t */\n\t__exportStar(Factory$5, exports);\n\t__exportStar(Instance$4, exports); \n} (externalApplication));\n\nvar frame = {};\n\nvar Factory$4 = {};\n\nvar Instance$3 = {};\n\nObject.defineProperty(Instance$3, \"__esModule\", { value: true });\nInstance$3._Frame = void 0;\n/* eslint-disable import/prefer-default-export */\nconst base_1$9 = base;\n/**\n * An iframe represents an embedded HTML page within a parent HTML page. Because this embedded page\n * has its own DOM and global JS context (which may or may not be linked to that of the parent depending\n * on if it is considered out of the root domain or not), it represents a unique endpoint as an OpenFin\n * connection. Iframes may be generated dynamically, or be present on initial page load and each non-CORS\n * iframe has the OpenFin API injected by default. It is possible to opt into cross-origin iframes having\n * the API by setting api.iframe.crossOriginInjection to true in a window's options. To block all iframes\n * from getting the API injected you can set api.frame.sameOriginInjection\n * to false <a href=\"Window.html#~options\" target=\"_blank\">({@link OpenFin.WindowCreationOptions see Window Options})</a>.\n *\n * To be able to directly address this context for eventing and messaging purposes, it needs a\n * unique uuid name pairing. For OpenFin applications and windows this is provided via a configuration\n * object in the form of a manifest URL or options object, but there is no configuration object for iframes.\n * Just as a call to window.open outside of our Window API returns a new window with a random GUID assigned\n * for the name, each iframe that has the API injected will be assigned a GUID as its name, the UUID will be\n * the same as the parent window's.\n *\n * The fin.Frame namespace represents a way to interact with `iframes` and facilitates the discovery of current context\n * (iframe or main window) as well as the ability to listen for {@link OpenFin.FrameEvents frame-specific events}.\n */\nclass _Frame extends base_1$9.EmitterBase {\n    /**\n     * @internal\n     */\n    constructor(wire, identity) {\n        super(wire, 'frame', identity.uuid, identity.name);\n        this.identity = identity;\n    }\n    /**\n     * Returns a frame info object for the represented frame.\n     *\n     * @example\n     * ```js\n     * async function getInfo() {\n     *     const frm = await fin.Frame.getCurrent();\n     *     return await frm.getInfo();\n     * }\n     * getInfo().then(info => console.log(info)).catch(err => console.log(err));\n     * ```\n     */\n    getInfo() {\n        return this.wire.sendAction('get-frame-info', this.identity).then(({ payload }) => payload.data);\n    }\n    /**\n     * Returns a frame info object representing the window that the referenced iframe is\n     * currently embedded in.\n     *\n     * @remarks If the frame is embedded in a view, this will return an invalid stub with empty fields.\n     *\n     * @example\n     * ```js\n     * async function getParentWindow() {\n     *     const frm = await fin.Frame.getCurrent();\n     *     return await frm.getParentWindow();\n     * }\n     * getParentWindow().then(winInfo => console.log(winInfo)).catch(err => console.log(err));\n     * ```\n     */\n    getParentWindow() {\n        return this.wire.sendAction('get-parent-window', this.identity).then(({ payload }) => payload.data);\n    }\n}\nInstance$3._Frame = _Frame;\n\nObject.defineProperty(Factory$4, \"__esModule\", { value: true });\nFactory$4._FrameModule = void 0;\nconst base_1$8 = base;\nconst validate_1$2 = validate;\nconst Instance_1$3 = Instance$3;\n/**\n * Static namespace for OpenFin API methods that interact with the {@link _Frame} class, available under `fin.Frame`.\n */\nclass _FrameModule extends base_1$8.Base {\n    /**\n     * Asynchronously returns an API handle for the given Frame identity.\n     *\n     * @remarks Wrapping a Frame identity that does not yet exist will *not* throw an error, and instead\n     * returns a stub object that cannot yet perform rendering tasks. This can be useful for plumbing eventing\n     * for a Frame throughout its entire lifecycle.\n     *\n     * @example\n     * ```js\n     * fin.Frame.wrap({ uuid: 'testFrame', name: 'testFrame' })\n     * .then(frm => console.log('wrapped frame'))\n     * .catch(err => console.log(err));\n     * ```\n     */\n    async wrap(identity) {\n        this.wire.sendAction('frame-wrap').catch((e) => {\n            // we do not want to expose this error, just continue if this analytics-only call fails\n        });\n        const errorMsg = (0, validate_1$2.validateIdentity)(identity);\n        if (errorMsg) {\n            throw new Error(errorMsg);\n        }\n        return new Instance_1$3._Frame(this.wire, identity);\n    }\n    /**\n     * Synchronously returns an API handle for the given Frame identity.\n     *\n     * @remarks Wrapping a Frame identity that does not yet exist will *not* throw an error, and instead\n     * returns a stub object that cannot yet perform rendering tasks. This can be useful for plumbing eventing\n     * for a Frame throughout its entire lifecycle.\n     *\n     * @example\n     * ```js\n     * const frm = fin.Frame.wrapSync({ uuid: 'testFrame', name: 'testFrame' });\n     * const info = await frm.getInfo();\n     * console.log(info);\n     * ```\n     */\n    wrapSync(identity) {\n        this.wire.sendAction('frame-wrap-sync').catch((e) => {\n            // we do not want to expose this error, just continue if this analytics-only call fails\n        });\n        const errorMsg = (0, validate_1$2.validateIdentity)(identity);\n        if (errorMsg) {\n            throw new Error(errorMsg);\n        }\n        return new Instance_1$3._Frame(this.wire, identity);\n    }\n    /**\n     * Asynchronously returns a reference to the current frame\n     *\n     * @example\n     * ```js\n     * fin.Frame.getCurrent()\n     * .then(frm => console.log('current frame'))\n     * .catch(err => console.log(err));\n     * ```\n     */\n    getCurrent() {\n        this.wire.sendAction('frame-get-current').catch((e) => {\n            // we do not want to expose this error, just continue if this analytics-only call fails\n        });\n        return Promise.resolve(new Instance_1$3._Frame(this.wire, this.wire.environment.getCurrentEntityIdentity()));\n    }\n    /**\n     * Synchronously returns a reference to the current frame\n     *\n     * @example\n     * ```js\n     * const frm = fin.Frame.getCurrentSync();\n     * const info = await frm.getInfo();\n     * console.log(info);\n     * ```\n     */\n    getCurrentSync() {\n        this.wire.sendAction('frame-get-current-sync').catch((e) => {\n            // we do not want to expose this error, just continue if this analytics-only call fails\n        });\n        return new Instance_1$3._Frame(this.wire, this.wire.environment.getCurrentEntityIdentity());\n    }\n}\nFactory$4._FrameModule = _FrameModule;\n\n(function (exports) {\n\t/**\n\t * Entry points for the OpenFin `Frame` API (`fin.Frame`).\n\t *\n\t * * {@link _FrameModule} contains static members of the `Frame` API, accessible through `fin.Frame`.\n\t * * {@link _Frame} describes an instance of an OpenFin Frame, e.g. as returned by `fin.Frame.getCurrent`.\n\t *\n\t * These are separate code entities, and are documented separately. In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/32.114.76.10/index.html),\n\t * both of these were documented on the same page.\n\t *\n\t * Underscore prefixing of OpenFin types that alias DOM entities will be fixed in a future version.\n\t *\n\t * @packageDocumentation\n\t */\n\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t    }\n\t    Object.defineProperty(o, k2, desc);\n\t}) : (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    o[k2] = m[k];\n\t}));\n\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t};\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t__exportStar(Factory$4, exports);\n\t__exportStar(Instance$3, exports); \n} (frame));\n\nvar globalHotkey = {};\n\nObject.defineProperty(globalHotkey, \"__esModule\", { value: true });\nglobalHotkey.GlobalHotkey = void 0;\nconst base_1$7 = base;\n/**\n * The GlobalHotkey module can register/unregister a global hotkeys.\n *\n */\nclass GlobalHotkey extends base_1$7.EmitterBase {\n    /**\n     * @internal\n     */\n    constructor(wire) {\n        super(wire, 'global-hotkey');\n    }\n    /**\n     * Registers a global hotkey with the operating system.\n     * @param hotkey a hotkey string\n     * @param listener called when the registered hotkey is pressed by the user.\n     * @throws If the `hotkey` is reserved, see list below.\n     * @throws if the `hotkey` is already registered by another application.\n     *\n     * @remarks The `hotkey` parameter expects an electron compatible [accelerator](https://github.com/electron/electron/blob/master/docs/api/accelerator.md) and the `listener` will be called if the `hotkey` is pressed by the user.\n     * If successfull, the hotkey will be 'claimed' by the application, meaning that this register call can be called multiple times from within the same application but will fail if another application has registered the hotkey.\n     * <br>The register call will fail if given any of these reserved Hotkeys:\n     * * `CommandOrControl+0`\n     * * `CommandOrControl+=`\n     * * `CommandOrControl+Plus`\n     * * `CommandOrControl+-`\n     * * `CommandOrControl+_`\n     * * `CommandOrControl+Shift+I`\n     * * `F5`\n     * * `CommandOrControl+R`\n     * * `Shift+F5`\n     * * `CommandOrControl+Shift+R`\n     *\n     * Raises the `registered` event.\n     *\n     * @example\n     * ```js\n     * const hotkey = 'CommandOrControl+X';\n     *\n     * fin.GlobalHotkey.register(hotkey, () => {\n     * console.log(`${hotkey} pressed`);\n     * })\n     * .then(() => {\n     *     console.log('Success');\n     * })\n     * .catch(err => {\n     *     console.log('Error registering the hotkey', err);\n     * });\n     * ```\n     */\n    async register(hotkey, listener) {\n        // TODO: fix typing (hotkey events are not typed)\n        // @ts-expect-error\n        await this.on(hotkey, listener);\n        await this.wire.sendAction('global-hotkey-register', { hotkey });\n        return undefined;\n    }\n    /**\n     * Unregisters a global hotkey with the operating system.\n     * @param hotkey a hotkey string\n     *\n     * @remarks This method will unregister all existing registrations of the hotkey within the application.\n     * Raises the `unregistered` event.\n     *\n     * @example\n     * ```js\n     * const hotkey = 'CommandOrControl+X';\n     *\n     * fin.GlobalHotkey.unregister(hotkey)\n     * .then(() => {\n     *     console.log('Success');\n     * })\n     * .catch(err => {\n     *     console.log('Error unregistering the hotkey', err);\n     * });\n     * ```\n     */\n    async unregister(hotkey) {\n        // TODO: fix typing (hotkey events are not typed)\n        // @ts-expect-error\n        await this.removeAllListeners(hotkey);\n        await this.wire.sendAction('global-hotkey-unregister', { hotkey });\n        return undefined;\n    }\n    /**\n     * Unregisters all global hotkeys for the current application.\n     *\n     * @remarks Raises the `unregistered` event for each hotkey unregistered.\n     *\n     * @example\n     * ```js\n     * fin.GlobalHotkey.unregisterAll()\n     * .then(() => {\n     *     console.log('Success');\n     * })\n     * .catch(err => {\n     *     console.log('Error unregistering all hotkeys for this application', err);\n     * });\n     * ```\n     */\n    async unregisterAll() {\n        await Promise.all(this.eventNames()\n            .filter((name) => !(name === 'registered' || name === 'unregistered'))\n            // TODO: fix typing (hotkey events are not typed)\n            // @ts-expect-error\n            .map((name) => this.removeAllListeners(name)));\n        await this.wire.sendAction('global-hotkey-unregister-all', {});\n        return undefined;\n    }\n    /**\n     * Checks if a given hotkey has been registered by an application within the current runtime.\n     * @param hotkey a hotkey string\n     *\n     * @example\n     * ```js\n     * const hotkey = 'CommandOrControl+X';\n     *\n     * fin.GlobalHotkey.isRegistered(hotkey)\n     * .then((registered) => {\n     *     console.log(`hotkey ${hotkey} is registered ? ${registered}`);\n     * })\n     * .catch(err => {\n     *     console.log('Error unregistering the hotkey', err);\n     * });\n     * ```\n     */\n    async isRegistered(hotkey) {\n        const { payload: { data } } = await this.wire.sendAction('global-hotkey-is-registered', { hotkey });\n        return data;\n    }\n}\nglobalHotkey.GlobalHotkey = GlobalHotkey;\n\nvar platform = {};\n\nvar Factory$3 = {};\n\nvar Instance$2 = {};\n\nvar __classPrivateFieldGet$5 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar _Platform_connectToProvider;\nObject.defineProperty(Instance$2, \"__esModule\", { value: true });\nInstance$2.Platform = void 0;\n/* eslint-disable import/prefer-default-export, no-undef */\nconst base_1$6 = base;\nconst validate_1$1 = validate;\n// Reuse clients to avoid overwriting already-registered client in provider\nconst clientMap = new Map();\n/** Manages the life cycle of windows and views in the application.\n *\n * Enables taking snapshots of itself and applying them to restore a previous configuration\n * as well as listen to {@link OpenFin.PlatformEvents platform events}.\n */\nclass Platform extends base_1$6.EmitterBase {\n    /**\n     * @internal\n     */\n    // eslint-disable-next-line no-shadow\n    constructor(identity, channel) {\n        // we piggyback off of application event emitter because from the core's perspective platform is just an app.\n        super(channel.wire, 'application', identity.uuid);\n        this.getClient = (identity) => {\n            this.wire.sendAction('platform-get-client', this.identity).catch((e) => {\n                // don't expose\n            });\n            const target = identity || this.identity;\n            const { uuid } = target;\n            if (!clientMap.has(uuid)) {\n                const clientPromise = __classPrivateFieldGet$5(this, _Platform_connectToProvider, \"f\").call(this, uuid);\n                clientMap.set(uuid, clientPromise);\n            }\n            // we set it above\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            return clientMap.get(uuid);\n        };\n        _Platform_connectToProvider.set(this, async (uuid) => {\n            try {\n                const channelName = `custom-frame-${uuid}`;\n                const client = await this._channel.connect(channelName, { wait: false });\n                client.onDisconnection(() => {\n                    clientMap.delete(uuid);\n                });\n                return client;\n            }\n            catch (e) {\n                clientMap.delete(uuid);\n                throw new Error('The targeted Platform is not currently running. Listen for application-started event for the given Uuid.');\n            }\n        });\n        /**\n         * @deprecated (renamed)\n         * @ignore\n         */\n        this.launchLegacyManifest = this.launchContentManifest;\n        const errorMsg = (0, validate_1$1.validateIdentity)(identity);\n        if (errorMsg) {\n            throw new Error(errorMsg);\n        }\n        this._channel = channel;\n        this.identity = { uuid: identity.uuid };\n        this.Layout = this.fin.Platform.Layout;\n        this.Application = this.fin.Application.wrapSync(this.identity);\n    }\n    /**\n     * Creates a new view and attaches it to a specified target window.\n     * @param viewOptions View creation options\n     * @param target The window to which the new view is to be attached. If no target, create a view in a new window.\n     * @param targetView If provided, the new view will be added to the same tabstrip as targetView.\n     *\n     * @remarks If the view already exists, will reparent the view to the new target. You do not need to set a name for a View.\n     * Views that are not passed a name get a randomly generated one.\n     *\n     * @example\n     * ```js\n     * let windowIdentity;\n     * if (fin.me.isWindow) {\n     *     windowIdentity = fin.me.identity;\n     * } else if (fin.me.isView) {\n     *     windowIdentity = (await fin.me.getCurrentWindow()).identity;\n     * } else {\n     *     throw new Error('Not running in a platform View or Window');\n     * }\n     *\n     * const platform = fin.Platform.getCurrentSync();\n     *\n     * platform.createView({\n     *     name: 'test_view',\n     *     url: 'https://developers.openfin.co/docs/platform-api'\n     * }, windowIdentity).then(console.log);\n     * ```\n     *\n     * Reparenting a view:\n     * ```js\n     * let windowIdentity;\n     * if (fin.me.isWindow) {\n     *     windowIdentity = fin.me.identity;\n     * } else if (fin.me.isView) {\n     *     windowIdentity = (await fin.me.getCurrentWindow()).identity;\n     * } else {\n     *     throw new Error('Not running in a platform View or Window');\n     * }\n     *\n     * let platform = fin.Platform.getCurrentSync();\n     * let viewOptions = {\n     *     name: 'example_view',\n     *     url: 'https://example.com'\n     * };\n     * // a new view will now show in the current window\n     * await platform.createView(viewOptions, windowIdentity);\n     *\n     * const view = fin.View.wrapSync({ uuid: windowIdentity.uuid, name: 'yahoo_view' });\n     * // reparent `example_view` when a view in the new window is shown\n     * view.on('shown', async () => {\n     *     let viewIdentity = { uuid: windowIdentity.uuid, name: 'example_view'};\n     *     let target = {uuid: windowIdentity.uuid, name: 'test_win'};\n     *     platform.createView(viewOptions, target);\n     * });\n     *\n     * // create a new window\n     * await platform.createWindow({\n     *     name: \"test_win\",\n     *     layout: {\n     *         content: [\n     *             {\n     *                 type: 'stack',\n     *                 content: [\n     *                     {\n     *                         type: 'component',\n     *                         componentName: 'view',\n     *                         componentState: {\n     *                             name: 'yahoo_view',\n     *                             url: 'https://yahoo.com'\n     *                         }\n     *                     }\n     *                 ]\n     *             }\n     *         ]\n     *     }\n     * }).then(console.log);\n     * ```\n     */\n    async createView(viewOptions, target, targetView) {\n        this.wire.sendAction('platform-create-view', this.identity).catch((e) => {\n            // don't expose\n        });\n        const client = await this.getClient();\n        const response = await client.dispatch('create-view', {\n            target,\n            opts: viewOptions,\n            targetView\n        });\n        if (!response || (0, validate_1$1.validateIdentity)(response.identity)) {\n            throw new Error(`When overwriting the createView call, please return an object that has a valid 'identity' property: ${JSON.stringify(response)}`);\n        }\n        return this.fin.View.wrapSync(response.identity);\n    }\n    /**\n     * Creates a new Window.\n     * @param options Window creation options\n     *\n     * @remarks There are two Window types at your disposal while using OpenFin Platforms - Default Window and Custom Window.\n     *\n     * The Default Window uses the standard OpenFin Window UI. It contains the standard close, maximize and minimize buttons,\n     * and will automatically render the Window's layout if one is specified.\n     *\n     * For deeper customization, you can bring your own Window code into a Platform. This is called a Custom Window.\n     *\n     * @example\n     *\n     *\n     * The example below will create a Default Window which uses OpenFin default Window UI.<br>\n     * The Window contains two Views in a stack Layout:\n     *\n     * ```js\n     * const platform = fin.Platform.getCurrentSync();\n     * platform.createWindow({\n     *     layout: {\n     *         content: [\n     *             {\n     *                 type: 'stack',\n     *                 content: [\n     *                     {\n     *                         type: 'component',\n     *                         componentName: 'view',\n     *                         componentState: {\n     *                             name: 'test_view_1',\n     *                             url: 'https://cdn.openfin.co/docs/javascript/canary/Platform.html'\n     *                         }\n     *                     },\n     *                     {\n     *                         type: 'component',\n     *                         componentName: 'view',\n     *                         componentState: {\n     *                             name: 'test_view_2',\n     *                             url: 'https://cdn.openfin.co/docs/javascript/canary/Platform.html'\n     *                         }\n     *                     }\n     *                 ]\n     *             }\n     *         ]\n     *     }\n     * }).then(console.log);\n     * ```\n     * The Default Window's design can be customized by specifying the `stylesheetUrl` property in the manifest:\n     *\n     * ```json\n     * {\n     *     platform: {\n     *         defaultWindowOptions: {\n     *             stylesheetUrl: 'some-url.css',\n     *             ...\n     *         }\n     *     }\n     * }\n     * ```\n     * For a list of common Layout CSS classes you can override in your custom stylesheet, see <a href=\"tutorial-layoutStyles.html\">Useful Layout CSS Classes</a>\n     **\n     * To specify a Platform Custom Window, provide a `url` property when creating a Window.\n     * If you intend to render a Layout in your Custom Window, you must also specify an `HTMLElement` that the Layout will inject into and set its `id` property to `\"layout-container\"`.\n     *\n     * The example below will create a Platform Custom Window:\n     *\n     * ```js\n     *     // in an OpenFin app:\n     *     const platform = fin.Platform.getCurrentSync();\n     *     const windowConfig =\n     *         {\n     *             url: \"https://www.my-domain.com/my-custom-window.html\", // here we point to where the Custom Frame is hosted.\n     *             layout: {\n     *                 content: [\n     *                     {\n     *                         type: \"stack\",\n     *                         content: [\n     *                             {\n     *                                 type: \"component\",\n     *                                 componentName: \"view\",\n     *                                 componentState: {\n     *                                     name: \"app #1\",\n     *                                     url: \"https://cdn.openfin.co/docs/javascript/canary/Platform.html\"\n     *                                 }\n     *                             },\n     *                             {\n     *                                 type: \"component\",\n     *                                 componentName: \"view\",\n     *                                 componentState: {\n     *                                     name: \"app #2\",\n     *                                     url: \"https://cdn.openfin.co/docs/javascript/canary/Platform.html\"\n     *                                 }\n     *                             }\n     *                         ]\n     *                     }\n     *                 ]\n     *             }\n     *         };\n     *     platform.createWindow(windowConfig);\n     * ```\n     *\n     * Here's an example of a minimalist Custom Platform Window implementation:\n     * ```html\n     * <html>\n     *     <head>\n     *         <meta charset=\"utf-8\">\n     *         <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n     *         <link rel=\"stylesheet\" type=\"text/css\" href=\"./styles.css\">\n     *     </head>\n     *     <body>\n     *         <div id=\"of-frame-main\">\n     *             <div id=\"title-bar\">\n     *                 <div class=\"title-bar-draggable\">\n     *                     <div id=\"title\"> This is a custom frame! </div>\n     *                 </div>\n     *                 <div id=\"buttons-wrapper\">\n     *                     <div class=\"button\" id=\"minimize-button\"></div>\n     *                     <div class=\"button\" id=\"expand-button\"></div>\n     *                     <div class=\"button\" id=\"close-button\"></div>\n     *                 </div>\n     *             </div>\n     *             <div id=\"layout-container\"></div> <!-- OpenFin layout would be injected here -->\n     *             <script src=\"./custom-frame.js\"></script>\n     *         </div>\n     *     </body>\n     * </html>\n     * ```\n     * Your Custom Window can use in-domain resources for further customization (such as CSS, scripts, etc.).<br>\n     * For a list of common Layout CSS classes you can override in your stylesheet, see <a href=\"tutorial-layoutStyles.html\">Useful Layout CSS Classes</a>\n     *\n     * The example above will require the `body` element to have `height: 100%;` set in order to render the layout correctly.\n     */\n    async createWindow(options) {\n        this.wire.sendAction('platform-create-window', this.identity).catch((e) => {\n            // don't expose\n        });\n        const client = await this.getClient();\n        if (!options.reason) {\n            options.reason = 'api-call';\n        }\n        const response = await client.dispatch('create-view-container', options);\n        if (!response || (0, validate_1$1.validateIdentity)(response.identity)) {\n            throw new Error(`When overwriting the createWindow call, please return an object that has a valid 'identity' property: ${JSON.stringify(response)}`);\n        }\n        const { identity } = response;\n        const res = this.fin.Window.wrapSync(identity);\n        // we add the identity at the top level for backwards compatibility.\n        res.name = identity.name;\n        res.uuid = identity.uuid;\n        return res;\n    }\n    /**\n     * Closes current platform, all its windows, and their views.\n     *\n     * @example\n     * ```js\n     * const platform = await fin.Platform.getCurrent();\n     * platform.quit();\n     * // All windows/views in current layout platform will close and platform will shut down\n     * ```\n     */\n    async quit() {\n        this.wire.sendAction('platform-quit', this.identity).catch((e) => {\n            // don't expose\n        });\n        const client = await this.getClient();\n        return client.dispatch('quit');\n    }\n    /**\n     * Closes a specified view in a target window.\n     * @param viewIdentity View identity\n     *\n     * @example\n     * ```js\n     * let windowIdentity;\n     * if (fin.me.isWindow) {\n     *     windowIdentity = fin.me.identity;\n     * } else if (fin.me.isView) {\n     *     windowIdentity = (await fin.me.getCurrentWindow()).identity;\n     * } else {\n     *     throw new Error('Not running in a platform View or Window');\n     * }\n     *\n     * const viewOptions = {\n     *     name: 'test_view',\n     *     url: 'https://example.com'\n     * };\n     *\n     * function sleep(ms) {\n     *     return new Promise(resolve => setTimeout(resolve, ms));\n     * }\n     *\n     * const platform = await fin.Platform.getCurrent();\n     *\n     * await platform.createView(viewOptions, windowIdentity);\n     * // a new view will now show in the current window\n     *\n     * await sleep(5000);\n     *\n     * const viewIdentity = { uuid: windowIdentity.uuid, name: 'test_view'};\n     * platform.closeView(viewIdentity);\n     * // the view will now close\n     * ```\n     */\n    async closeView(viewIdentity) {\n        this.wire.sendAction('platform-close-view', this.identity).catch((e) => {\n            // don't expose\n        });\n        const client = await this.getClient();\n        await client.dispatch('close-view', {\n            view: viewIdentity\n        });\n    }\n    /**\n     * ***DEPRECATED - please use {@link Platform.createView Platform.createView}.***\n     * Reparents a specified view in a new target window.\n     * @param viewIdentity View identity\n     * @param target new owner window identity\n     *\n     */\n    async reparentView(viewIdentity, target) {\n        // eslint-disable-next-line no-console\n        console.warn('Platform.reparentView has been deprecated, please use Platform.createView');\n        this.wire.sendAction('platform-reparent-view', this.identity).catch((e) => {\n            // don't expose\n        });\n        const normalizedViewIdentity = {\n            ...viewIdentity,\n            uuid: viewIdentity.uuid ?? this.identity.uuid\n        };\n        const view = await this.fin.View.wrap(normalizedViewIdentity);\n        const viewOptions = await view.getOptions();\n        return this.createView(viewOptions, target);\n    }\n    /**\n     * Returns a snapshot of the platform in its current state. You can pass the returning object to\n     * [Platform.applySnapshot]{@link Platform#applySnapshot} to launch it.\n     *\n     * @remarks The snapshot will include details such as an [ISO format](https://en.wikipedia.org/wiki/ISO_8601)\n     * timestamp of when the snapshot was taken, OpenFin runtime version the platform is running on, monitor information\n     * and the list of currently running windows.\n     *\n     * @example\n     * ```js\n     * const platform = await fin.Platform.getCurrent();\n     * const snapshot = await platform.getSnapshot();\n     * ```\n     */\n    async getSnapshot() {\n        this.wire.sendAction('platform-get-snapshot', this.identity).catch((e) => {\n            // don't expose\n        });\n        const client = await this.getClient();\n        return client.dispatch('get-snapshot');\n    }\n    /**\n     * **NOTE**: Internal use only. It is not recommended to manage the state of individual views.\n     *\n     * Returns a snapshot of a single view's options in its current state.\n     *\n     * Can be used to restore a view to a previous state.\n     *\n     * @param viewIdentity View identity\n     *\n     * @internal\n     * @experimental\n     * @remarks This slice of snapshot state is equivalent to what is stored as `componentState` for views\n     * when capturing platform state using [Platform.getSnapshot]{@link Platform#getSnapshot}.\n     *\n     * @example\n     * ```js\n     * const platform = await fin.Platform.getCurrent();\n     * const url = 'https://google.com';\n     * const view = await fin.View.create({ name: 'my-view', target: fin.me.identity, url });\n     *\n     * await view.navigate(url);\n     *\n     * const viewState = await platform.getViewSnapshot(view.identity);\n     *\n     * console.log(viewState);\n     * ```\n     */\n    async getViewSnapshot(viewIdentity) {\n        const client = await this.getClient();\n        return client.dispatch('get-view-snapshot', { viewIdentity });\n    }\n    /**\n     * Adds a snapshot to a running Platform.\n     * Requested snapshot must be a valid Snapshot object, or a url or filepath to such an object.\n     *\n     * Can optionally close existing windows and overwrite current platform state with that of a snapshot.\n     *\n     * The function accepts either a snapshot taken using {@link Platform#getSnapshot getSnapshot},\n     * or a url or filepath to a snapshot JSON object.\n     * @param requestedSnapshot Snapshot to apply, or a url or filepath.\n     * @param options Optional parameters to specify whether existing windows should be closed.\n     *\n     * @remarks Will create any windows and views that are not running but are passed in the snapshot object. Any View\n     * specified in the snapshot is assigned a randomly generated name to avoid collisions.\n     *\n     * @example\n     * ```js\n     * // Get a wrapped layout platform instance\n     * const platform = await fin.Platform.getCurrent();\n     *\n     * const snapshot = {\n     *     windows: [\n     *         {\n     *             layout: {\n     *                 content: [\n     *                     {\n     *                         type: 'stack',\n     *                         content: [\n     *                             {\n     *                                 type: 'component',\n     *                                 componentName: 'view',\n     *                                 componentState: {\n     *                                     name: 'component_X',\n     *                                     url: 'https://www.openfin.co'\n     *                                 }\n     *                             },\n     *                             {\n     *                                 type: 'component',\n     *                                 componentName: 'view',\n     *                                 componentState: {\n     *                                     name: 'component_Y',\n     *                                     url: 'https://cdn.openfin.co/embed-web/chart.html'\n     *                                 }\n     *                             }\n     *                         ]\n     *                     }\n     *                 ]\n     *             }\n     *         }\n     *     ]\n     * }\n     *\n     * platform.applySnapshot(snapshot);\n     * ```\n     *\n     * In place of a snapshot object, `applySnapshot` can take a url or filepath and to retrieve a JSON snapshot.\n     *\n     * ```js\n     * const platform = await fin.Platform.getCurrent();\n     * platform.applySnapshot('https://api.jsonbin.io/b/5e6f903ef4331e681fc1231d/1');\n     * ```\n     *\n     * Optionally, `applySnapshot` can close existing windows and restore a Platform to a previously saved state.\n     * This is accomplished by providing `{ closeExistingWindows: true }` as an option.\n     *\n     * ```js\n     * // Get a wrapped layout platform instance\n     * const platform = await fin.Platform.getCurrent();\n     *\n     * async function addViewToWindow(winId) {\n     *     return await platform.createView({\n     *         name: 'test_view_3',\n     *         url: 'https://openfin.co'\n     *     }, winId);\n     * }\n     *\n     * async function createWindowWithTwoViews() {\n     *     const platform = await fin.Platform.getCurrent();\n     *\n     *     return platform.createWindow({\n     *         layout: {\n     *             content: [\n     *                 {\n     *                     type: 'stack',\n     *                     content: [\n     *                         {\n     *                             type: 'component',\n     *                             componentName: 'view',\n     *                             componentState: {\n     *                                 name: 'test_view_1',\n     *                                 url: 'https://example.com'\n     *                             }\n     *                         },\n     *                         {\n     *                             type: 'component',\n     *                             componentName: 'view',\n     *                             componentState: {\n     *                                 name: 'test_view_2',\n     *                                 url: 'https://yahoo.com'\n     *                             }\n     *                         }\n     *                     ]\n     *                 }\n     *             ]\n     *         }\n     *     });\n     * }\n     *\n     * const win = await createWindowWithTwoViews();\n     * // ... you will now see a new window with two views in it\n     *\n     * // we take a snapshot of the current state of the app, before changing it\n     * const snapshotOfInitialAppState = await platform.getSnapshot();\n     *\n     * // now let's change the state of the app:\n     * await addViewToWindow(win.identity);\n     * // ... the window now has three views in it\n     *\n     * await platform.applySnapshot(snapshotOfInitialAppState, { closeExistingWindows: true });\n     * // ... the window will revert to previous state, with just two views\n     *\n     * ```\n     */\n    async applySnapshot(requestedSnapshot, options) {\n        this.wire.sendAction('platform-apply-snapshot', this.identity).catch((e) => {\n            // don't expose\n        });\n        const errMsg = 'Requested snapshot must be a valid Snapshot object, or a url or filepath to such an object.';\n        let snapshot;\n        if (typeof requestedSnapshot === 'string') {\n            // Fetch and parse snapshot\n            try {\n                const response = await this._channel.wire.sendAction('get-application-manifest', {\n                    manifestUrl: requestedSnapshot\n                });\n                snapshot = response.payload.data;\n            }\n            catch (err) {\n                throw new Error(`${errMsg}: ${err}`);\n            }\n        }\n        else {\n            snapshot = requestedSnapshot;\n        }\n        if (!snapshot.windows) {\n            throw new Error(errMsg);\n        }\n        const client = await this.getClient();\n        await client.dispatch('apply-snapshot', {\n            snapshot,\n            options\n        });\n        return this;\n    }\n    /**\n     * Fetches a JSON manifest using the browser process and returns a Javascript object.\n     * Can be overwritten using {@link Platform.PlatformModule.init Platform.init}.\n     * @param manifestUrl The URL of the manifest to fetch.\n     *\n     * @remarks Can be overwritten using {@link Platform#init Platform.init}.\n     *\n     * @example\n     *\n     * ```js\n     * const platform = fin.Platform.getCurrentSync();\n     * const manifest = await platform.fetchManifest('https://www.path-to-manifest.com/app.json');\n     * console.log(manifest);\n     * ```\n     */\n    async fetchManifest(manifestUrl) {\n        const client = await this.getClient();\n        return client.dispatch('platform-fetch-manifest', { manifestUrl });\n    }\n    /**\n     * Retrieves a manifest by url and launches a legacy application manifest or snapshot into the platform.  Returns a promise that\n     * resolves to the wrapped Platform.\n     * @param manifestUrl - The URL of the manifest that will be launched into the platform.  If this app manifest\n     * contains a snapshot, that will be launched into the platform.  If not, the application described in startup_app options\n     * will be launched into the platform. The applicable startup_app options will become {@link OpenFin.ViewCreationOptions View Options}.\n     *\n     * @remarks If the app manifest contains a snapshot, that will be launched into the platform.  If not, the\n     * application described in startup_app options will be launched into the platform as a window with a single view.\n     * The applicable startup_app options will become View Options.\n     *\n     * @example\n     * ```js\n     * try {\n     *     const platform = fin.Platform.getCurrentSync();\n     *     await platform.launchContentManifest('http://localhost:5555/app.json');\n     *     console.log(`content launched successfully into platform`);\n     * } catch(e) {\n     *     console.error(e);\n     * }\n     * // For a local manifest file:\n     * try {\n     *     const platform = fin.Platform.getCurrentSync();\n     *     platform.launchContentManifest('file:///C:/somefolder/app.json');\n     *     console.log(`content launched successfully into platform`);\n     * } catch(e) {\n     *     console.error(e);\n     * }\n     * ```\n     * @experimental\n     */\n    async launchContentManifest(manifestUrl) {\n        this.wire.sendAction('platform-launch-content-manifest', this.identity).catch(() => {\n            // don't expose\n        });\n        const client = await this.getClient();\n        const manifest = await this.fetchManifest(manifestUrl);\n        client.dispatch('launch-into-platform', { manifest, manifestUrl });\n        return this;\n    }\n    /**\n     * Set the context of a host window. The context will be available to the window itself, and to its child Views. It will be saved in any platform snapshots.\n     * It can be retrieved using {@link Platform#getWindowContext getWindowContext}.\n     * @param context - A field where serializable context data can be stored to be saved in platform snapshots.\n     * @param target - A target window or view may optionally be provided. If no target is provided, the update will be applied\n     * to the current window (if called from a Window) or the current host window (if called from a View).\n     *\n     * @remarks The context data must be serializable.  This can only be called from a window or view that has been launched into a\n     * platform.\n     * This method can be called from the window itself, or from any child view. Context data is shared by all\n     * entities within a window.\n     *\n     * @example\n     * Setting own context:\n     * ```js\n     * const platform = fin.Platform.getCurrentSync();\n     * const contextData = {\n     *     security: 'STOCK',\n     *     currentView: 'detailed'\n     * }\n     *\n     * await platform.setWindowContext(contextData);\n     * // Context of current window is now set to `contextData`\n     * ```\n     *\n     * Setting the context of another window or view:\n     * ```js\n     * const platform = fin.Platform.getCurrentSync();\n     * const contextData = {\n     *     security: 'STOCK',\n     *     currentView: 'detailed'\n     * }\n     *\n     * const windowOrViewIdentity = { uuid: fin.me.uuid, name: 'nameOfWindowOrView' };\n     * await platform.setWindowContext(contextData, windowOrViewIdentity);\n     * // Context of the target window or view is now set to `contextData`\n     * ```\n     *\n     * A view can listen to changes to its host window's context by listening to the `host-context-changed` event.\n     * This event will fire when a host window's context is updated or when the view is reparented to a new window:\n     *\n     * ```js\n     * // From a view\n     * const contextChangeHandler = ({ context }) => {\n     *     console.log('Host window\\'s context has changed. New context data:', context);\n     *     // react to new context data here\n     * }\n     * await fin.me.on('host-context-changed', contextChangeHandler);\n     *\n     * const platform = await fin.Platform.getCurrentSync();\n     * const contextData = {\n     *     security: 'STOCK',\n     *     currentView: 'detailed'\n     * }\n     * platform.setWindowContext(contextData) // contextChangeHandler will log the new context\n     * ```\n     *\n     * To listen to a window's context updates, use the `context-changed` event:\n     * ```js\n     * // From a window\n     * const contextChangeHandler = ({ context }) => {\n     *     console.log('This window\\'s context has changed. New context data:', context);\n     *     // react to new context data here\n     * }\n     * await fin.me.on('context-changed', contextChangeHandler);\n     *\n     * const platform = await fin.Platform.getCurrentSync();\n     * const contextData = {\n     *     security: 'STOCK',\n     *     currentView: 'detailed'\n     * }\n     * platform.setWindowContext(contextData) // contextChangeHandler will log the new context\n     * ```\n     * @experimental\n     */\n    async setWindowContext(context = {}, target) {\n        this.wire.sendAction('platform-set-window-context', this.identity).catch((e) => {\n            // don't expose\n        });\n        if (!context) {\n            throw new Error('Please provide a serializable object or string to set the context.');\n        }\n        const client = await this.getClient();\n        const { entityType } = target ? await this.fin.System.getEntityInfo(target.uuid, target.name) : this.fin.me;\n        await client.dispatch('set-window-context', {\n            context,\n            entityType,\n            target: target || { uuid: this.fin.me.uuid, name: this.fin.me.name }\n        });\n    }\n    /**\n     * Get the context context of a host window that was previously set using {@link Platform#setWindowContext setWindowContext}.\n     * The context will be saved in any platform snapshots.  Returns a promise that resolves to the context.\n     * @param target - A target window or view may optionally be provided. If no target is provided, target will be\n     * the current window (if called from a Window) or the current host window (if called from a View).\n     *\n     * @remarks This method can be called from the window itself, or from any child view. Context data is shared\n     * by all entities within a window.\n     *\n     * @example\n     *\n     * Retrieving context from current window:\n     * ```js\n     * const platform = fin.Platform.getCurrentSync();\n     * const customContext = { answer: 42 };\n     * await platform.setWindowContext(customContext);\n     *\n     * const myContext = await platform.getWindowContext();\n     * console.log(myContext); // { answer: 42 }\n     * ```\n     *\n     * Retrieving the context of another window or view:\n     * ```js\n     * const platform = fin.Platform.getCurrentSync();\n     *\n     * const windowOrViewIdentity = { uuid: fin.me.uuid, name: 'nameOfWindowOrView' };\n     *\n     * const targetWindowContext = await platform.getWindowContext(windowOrViewIdentity);\n     * console.log(targetWindowContext); // context of target window\n     * ```\n     * @experimental\n     */\n    async getWindowContext(target) {\n        this.wire.sendAction('platform-get-window-context', this.identity).catch((e) => {\n            // don't expose\n        });\n        const client = await this.getClient();\n        const { entityType } = target ? await this.fin.System.getEntityInfo(target.uuid, target.name) : this.fin.me;\n        return client.dispatch('get-window-context', {\n            target: target || { uuid: this.fin.me.uuid, name: this.fin.me.name },\n            entityType\n        });\n    }\n    /**\n     * Closes a window. If enableBeforeUnload is enabled in the Platform options, any beforeunload handler set on Views will fire\n     * This behavior can be disabled by setting skipBeforeUnload to false in the options parameter.\n     * @param winId\n     * @param options\n     *\n     * @remarks This method works by setting a `close-requested` handler on the Platform Window. If you have your own `close-requested` handler set on the Platform Window as well,\n     * it is recommended to move that logic over to the [PlatformProvider.closeWindow]{@link PlatformProvider#closeWindow} override to ensure it runs when the Window closes.\n     *\n     * @example\n     *\n     * ```js\n     * // Close the current Window inside a Window context\n     * const platform = await fin.Platform.getCurrent();\n     * platform.closeWindow(fin.me.identity);\n     *\n     * // Close the Window from inside a View context\n     * const platform = await fin.Platform.getCurrent();\n     * const parentWindow = await fin.me.getCurrentWindow();\n     * platform.closeWindow(parentWindow.identity);\n     *\n     * // Close the Window and do not fire the before unload handler on Views\n     * const platform = await fin.Platform.getCurrent();\n     * platform.closeWindow(fin.me.identity, { skipBeforeUnload: true });\n     * ```\n     * @experimental\n     */\n    async closeWindow(windowId, options = { skipBeforeUnload: false }) {\n        this.wire.sendAction('platform-close-window', this.identity).catch((e) => {\n            // don't expose\n        });\n        const client = await this.getClient();\n        return client.dispatch('close-window', { windowId, options });\n    }\n}\nInstance$2.Platform = Platform;\n_Platform_connectToProvider = new WeakMap();\n\nvar layout = {};\n\nvar Factory$2 = {};\n\nvar Instance$1 = {};\n\nvar commonUtils = {};\n\nObject.defineProperty(commonUtils, \"__esModule\", { value: true });\ncommonUtils.overrideFromComposables = commonUtils.isValidPresetType = void 0;\nfunction isValidPresetType(type) {\n    switch (type) {\n        case 'columns':\n        case 'grid':\n        case 'rows':\n        case 'tabs':\n            return true;\n        default:\n            return false;\n    }\n}\ncommonUtils.isValidPresetType = isValidPresetType;\nfunction overrideFromComposables(...overrides) {\n    return (base) => overrides.reduceRight((p, c) => (b) => c(p(b)), (x) => x)(base);\n}\ncommonUtils.overrideFromComposables = overrideFromComposables;\ncommonUtils.default = { isValidPresetType };\n\nvar __classPrivateFieldGet$4 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar _Layout_layoutClient;\nObject.defineProperty(Instance$1, \"__esModule\", { value: true });\nInstance$1.Layout = void 0;\nconst lazy_1 = lazy;\nconst validate_1 = validate;\nconst base_1$5 = base;\nconst common_utils_1 = commonUtils;\nconst layout_entities_1 = layoutEntities;\nconst layout_constants_1$1 = layout_constants;\n/**\n *\n * Layouts give app providers the ability to embed multiple views in a single window. The Layout namespace\n * enables the initialization and manipulation of a window's Layout. A Layout will\n * emit events locally on the DOM element representing the layout-container.\n *\n *\n * ### Layout.DOMEvents\n *\n * When a Layout is created, it emits events onto the DOM element representing the Layout container.\n * This Layout container is the DOM element referenced by containerId in {@link Layout.LayoutModule#init Layout.init}.\n * You can use the built-in event emitter to listen to these events using [addEventListener](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener).\n * The events are emitted synchronously and only in the process where the Layout exists.\n * Any values returned by the called listeners are ignored and will be discarded.\n * If the target DOM element is destroyed, any events that have been set up on that element will be destroyed.\n *\n * @remarks The built-in event emitter is not an OpenFin event emitter so it doesn't share propagation semantics.\n *\n * #### {@link https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener addEventListener(type, listener [, options]);}\n * Adds a listener to the end of the listeners array for the specified event.\n * @example\n * ```js\n * const myLayoutContainer = document.getElementById('layout-container');\n *\n * myLayoutContainer.addEventListener('tab-created', function(event) {\n *      const { tabSelector } = event.detail;\n *      const tabElement = document.getElementById(tabSelector);\n *      const existingColor = tabElement.style.backgroundColor;\n *      tabElement.style.backgroundColor = \"red\";\n *      setTimeout(() => {\n *          tabElement.style.backgroundColor = existingColor;\n *      }, 2000);\n * });\n * ```\n *\n * #### {@link https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/removeEventListener removeEventListener(type, listener [, options]);}\n * Adds a listener to the end of the listeners array for the specified event.\n * @example\n * ```js\n * const myLayoutContainer = document.getElementById('layout-container');\n *\n * const listener = function(event) {\n *     console.log(event.detail);\n *     console.log('container-created event fired once, removing listener');\n *     myLayoutContainer.removeEventListener('container-created', listener);\n * };\n *\n * myLayoutContainer.addEventListener('container-created', listener);\n * ```\n *\n * ### Supported event types are:\n *\n * * tab-created\n * * container-created\n * * layout-state-changed\n * * tab-closed\n * * tab-dropped\n *\n * ### Layout DOM Node Events\n *\n * #### tab-created\n * Generated when a tab is created.  As a user drags and drops tabs within window, new tabs are created.  A single view may have multiple tabs created and destroyed during its lifetime attached to a single window.\n * ```js\n * // The response has the following shape in event.detail:\n * {\n *     containerSelector: \"container-component_A\",\n *     name: \"component_A\",\n *     tabSelector: \"tab-component_A\",\n *     topic: \"openfin-DOM-event\",\n *     type: \"tab-created\",\n *     uuid: \"OpenFin POC\"\n * }\n * ```\n *\n * #### container-created\n * Generated when a container is created.  A single view will have only one container during its lifetime attached to a single window and the container's lifecycle is tied to the view.  To discover when the container is destroyed, please listen to view-detached event.\n * ```js\n * // The response has the following shape in event.detail:\n * {\n *     containerSelector: \"container-component_A\",\n *     name: \"component_A\",\n *     tabSelector: \"tab-component_A\",\n *     topic: \"openfin-DOM-event\",\n *     type: \"container-created\",\n *     uuid: \"OpenFin POC\"\n * }\n * ```\n *\n * ### layout-state-changed\n * Generated when the state of the layout changes in any way, such as a view added/removed/replaced. Note that this event can fire frequently as the underlying layout can change multiple components from all kinds of changes (resizing for example). Given this, it is recommended to debounce this event and then you can use the {@link Layout#getConfig Layout.getConfig} API to retrieve the most up-to-date state.\n * ```js\n * // The response has the following shape in event.detail\n * {\n *     containerSelector: \"container-component_A\",\n *     name: \"component_A\",\n *     tabSelector: \"tab-component_A\",\n *     topic: \"openfin-DOM-event\",\n *     type: \"layout-state-changed\",\n *     uuid: \"OpenFin POC\"\n * }\n * ```\n *\n * #### tab-closed\n * Generated when a tab is closed.\n * ```js\n * // The response has the following shape in event.detail:\n * {\n *     containerSelector: \"container-component_A\",\n *     name: \"component_A\",\n *     tabSelector: \"tab-component_A\",\n *     topic: \"openfin-DOM-event\",\n *     type: \"tab-closed\",\n *     uuid: \"OpenFin POC\",\n *     url: \"http://openfin.co\"   // The url of the view that was closed.\n * }\n * ```\n *\n * #### tab-dropped\n * Generated when a tab is dropped.\n * ```js\n * // The response has the following shape in event.detail:\n * {\n *     containerSelector: \"container-component_A\",\n *     name: \"component_A\",\n *     tabSelector: \"tab-component_A\",\n *     topic: \"openfin-DOM-event\",\n *     type: \"tab-dropped\",\n *     uuid: \"OpenFin POC\",\n *     url: \"http://openfin.co\"    // The url of the view linked to the dropped tab.\n * }\n * ```\n */\nclass Layout extends base_1$5.Base {\n    /**\n     * @internal\n     */\n    // eslint-disable-next-line no-shadow\n    constructor(identity, wire) {\n        super(wire);\n        /**\n         * @internal\n         * Lazily constructed {@link LayoutEntitiesClient} bound to this platform's client and identity\n         * The client is for {@link LayoutEntitiesController}\n         */\n        _Layout_layoutClient.set(this, new lazy_1.Lazy(async () => layout_entities_1.LayoutNode.newLayoutEntitiesClient(await this.platform.getClient(), layout_constants_1$1.LAYOUT_CONTROLLER_ID, this.identity)));\n        /**\n         * Replaces a Platform window's layout with a new layout.\n         *\n         * @remarks Any views that were in the old layout but not the new layout will be destroyed. Views will be assigned a randomly generated name to avoid collisions.\n         * @example\n         * ```js\n         * let windowIdentity;\n         * if (fin.me.isWindow) {\n         *     windowIdentity = fin.me.identity;\n         * } else if (fin.me.isView) {\n         *     windowIdentity = (await fin.me.getCurrentWindow()).identity;\n         * } else {\n         *     throw new Error('Not running in a platform View or Window');\n         * }\n         *\n         * const layout = fin.Platform.Layout.wrapSync(windowIdentity);\n         *\n         * const newLayout = {\n         *     content: [\n         *         {\n         *             type: 'stack',\n         *             content: [\n         *                 {\n         *                     type: 'component',\n         *                     componentName: 'view',\n         *                     componentState: {\n         *                         name: 'new_component_A1',\n         *                         processAffinity: 'ps_1',\n         *                         url: 'https://www.example.com'\n         *                     }\n         *                 },\n         *                 {\n         *                     type: 'component',\n         *                     componentName: 'view',\n         *                     componentState: {\n         *                         name: 'new_component_A2',\n         *                         url: 'https://cdn.openfin.co/embed-web/chart.html'\n         *                     }\n         *                 }\n         *             ]\n         *         }\n         *     ]\n         * };\n         *\n         * layout.replace(newLayout);\n         * ```\n         */\n        this.replace = async (layout) => {\n            this.wire.sendAction('layout-replace').catch((e) => {\n                // don't expose\n            });\n            const client = await this.platform.getClient();\n            await client.dispatch('replace-layout', {\n                target: this.identity,\n                opts: { layout }\n            });\n        };\n        /**\n         * Replaces the specified view with a view with the provided configuration.\n         *\n         * @remarks The old view is stripped of its listeners and either closed or attached to the provider window\n         * depending on `detachOnClose` view option.\n         *\n         * @param viewToReplace Identity of the view to be replaced\n         * @param newView Creation options of the new view.\n         *\n         * @example\n         * ```js\n         * let currentWindow;\n         * if (fin.me.isWindow) {\n         *     currentWindow = fin.me;\n         * } else if (fin.me.isView) {\n         *     currentWindow = await fin.me.getCurrentWindow();\n         * } else {\n         *     throw new Error('Not running in a platform View or Window');\n         * }\n         *\n         * const layout = fin.Platform.Layout.wrapSync(currentWindow.identity);\n         * const viewToReplace = (await currentWindow.getCurrentViews())[0];\n         * const newViewConfig = {url: 'https://example.com'};\n         * await layout.replaceView(viewToReplace.identity, newViewConfig);\n         * ```\n         */\n        this.replaceView = async (viewToReplace, newView) => {\n            this.wire.sendAction('layout-replace-view').catch((e) => {\n                // don't expose\n            });\n            const client = await this.platform.getClient();\n            await client.dispatch('replace-view', {\n                target: this.identity,\n                opts: { viewToReplace, newView }\n            });\n        };\n        /**\n         * Replaces a Platform window's layout with a preset layout arrangement using the existing Views attached to the window.\n         * The preset options are `columns`, `grid`, `rows`, and `tabs`.\n         * @param options Mandatory object with `presetType` property that sets which preset layout arrangement to use.\n         * The preset options are `columns`, `grid`, `rows`, and `tabs`.\n         *\n         * @example\n         * ```js\n         * let windowIdentity;\n         * if (fin.me.isWindow) {\n         *     windowIdentity = fin.me.identity;\n         * } else if (fin.me.isView) {\n         *     windowIdentity = (await fin.me.getCurrentWindow()).identity;\n         * } else {\n         *     throw new Error('Not running in a platform View or Window');\n         * }\n         *\n         * const layout = fin.Platform.Layout.wrapSync(windowIdentity);\n         * await layout.applyPreset({ presetType: 'grid' });\n         *\n         * // wait 5 seconds until you change the layout from grid to tabs\n         * await new Promise (res => setTimeout(res, 5000));\n         * await layout.applyPreset({ presetType: 'tabs' });\n         * ```\n         */\n        this.applyPreset = async (options) => {\n            this.wire.sendAction('layout-apply-preset').catch((e) => {\n                // don't expose\n            });\n            const client = await this.platform.getClient();\n            const { presetType } = options;\n            if (!presetType || !(0, common_utils_1.isValidPresetType)(presetType)) {\n                throw new Error('Cannot apply preset layout, please include an applicable presetType property in the PresetLayoutOptions.');\n            }\n            await client.dispatch('apply-preset-layout', {\n                target: this.identity,\n                opts: { presetType }\n            });\n        };\n        const errorMsg = (0, validate_1.validateIdentity)(identity);\n        if (errorMsg) {\n            throw new Error(errorMsg);\n        }\n        this.identity = identity;\n        this.platform = this.fin.Platform.wrapSync({ uuid: identity.uuid });\n        if (identity.uuid === this.fin.me.uuid && identity.name === this.fin.me.name) {\n            this.init = this.fin.Platform.Layout.init;\n        }\n    }\n    /**\n     * Returns the configuration of the window's layout.  Returns the same information that is returned for all windows in getSnapshot.\n     *\n     * @remarks Cannot be called from a View.\n     *\n     *\n     * @example\n     * ```js\n     * const layout = fin.Platform.Layout.getCurrentSync();\n     * // Use wrapped instance to get the layout configuration of the current window's Layout:\n     * const layoutConfig = await layout.getConfig();\n     * ```\n     */\n    async getConfig() {\n        this.wire.sendAction('layout-get-config').catch((e) => {\n            // don't expose\n        });\n        const client = await this.platform.getClient();\n        return client.dispatch('get-frame-snapshot', {\n            target: this.identity\n        });\n    }\n    /**\n     * Retrieves the attached views in current window layout.\n     *\n     * @example\n     * ```js\n     * const layout = fin.Platform.Layout.getCurrentSync();\n     * const views = await layout.getCurrentViews();\n     * ```\n     */\n    async getCurrentViews() {\n        this.wire.sendAction('layout-get-views').catch((e) => {\n            // don't expose\n        });\n        const client = await this.platform.getClient();\n        const viewIdentities = await client.dispatch('get-layout-views', {\n            target: this.identity\n        });\n        return viewIdentities.map((identity) => this.fin.View.wrapSync(identity));\n    }\n    /**\n     * Retrieves the top level content item of the layout.\n     *\n     * @remarks Cannot be called from a view.\n     *\n     *\n     *\n     * @example\n     * ```js\n     * if (!fin.me.isWindow) {\n     *     throw new Error('Not running in a platform View.');\n     * }\n     *\n     * // From the layout window\n     * const layout = fin.Platform.Layout.getCurrentSync();\n     * // Retrieves the ColumnOrRow instance\n     * const rootItem = await layout.getRootItem();\n     * const content = await rootItem.getContent();\n     * console.log(`The root ColumnOrRow instance has ${content.length} item(s)`);\n     * ```\n     */\n    async getRootItem() {\n        this.wire.sendAction('layout-get-root-item').catch(() => {\n            // don't expose\n        });\n        const client = await __classPrivateFieldGet$4(this, _Layout_layoutClient, \"f\").getValue();\n        const root = await client.getRoot('layoutName' in this.identity ? this.identity : undefined);\n        return layout_entities_1.LayoutNode.getEntity(root, client);\n    }\n}\nInstance$1.Layout = Layout;\n_Layout_layoutClient = new WeakMap();\n\nvar __classPrivateFieldGet$3 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar __classPrivateFieldSet$3 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar _LayoutModule_instances, _LayoutModule_layoutInitializationAttempted, _LayoutModule_layoutManager, _LayoutModule_getLayoutManagerSpy, _LayoutModule_getSafeLayoutManager;\nObject.defineProperty(Factory$2, \"__esModule\", { value: true });\nFactory$2.LayoutModule = void 0;\nconst base_1$4 = base;\nconst Instance_1$2 = Instance$1;\nconst layout_constants_1 = layout_constants;\n/**\n * Static namespace for OpenFin API methods that interact with the {@link Layout} class, available under `fin.Platform.Layout`.\n */\nclass LayoutModule extends base_1$4.Base {\n    constructor() {\n        super(...arguments);\n        _LayoutModule_instances.add(this);\n        _LayoutModule_layoutInitializationAttempted.set(this, false);\n        _LayoutModule_layoutManager.set(this, null);\n        /**\n         * Initialize the window's Layout.\n         *\n         * @remarks Must be called from a custom window that has a 'layout' option set upon creation of that window.\n         * If a containerId is not provided, this method attempts to find an element with the id `layout-container`.\n         * A Layout will emit events locally on the DOM element representing the layout-container.\n         * In order to capture the relevant events during Layout initiation, set up the listeners on the DOM element prior to calling `init`.\n         * @param options - Layout init options.\n         *\n         * @experimental\n         *\n         * @example\n         * ```js\n         * // If no options are included, the layout in the window options is initialized in an element with the id `layout-container`\n         * const layout = await fin.Platform.Layout.init();\n         * ```\n         * <br>\n         *\n         * ```js\n         * const containerId = 'my-custom-container-id';\n         *\n         * const myLayoutContainer = document.getElementById(containerId);\n         *\n         * myLayoutContainer.addEventListener('tab-created', function(event) {\n         *     const { tabSelector } = event.detail;\n         *     const tabElement = document.getElementById(tabSelector);\n         *     const existingColor = tabElement.style.backgroundColor;\n         *     tabElement.style.backgroundColor = \"red\";\n         *     setTimeout(() => {\n         *         tabElement.style.backgroundColor = existingColor;\n         *     }, 2000);\n         * });\n         *\n         * // initialize the layout into an existing HTML element with the div `my-custom-container-id`\n         * // the window must have been created with a layout in its window options\n         * const layout = await fin.Platform.Layout.init({ containerId });\n         * ```\n         */\n        this.init = async (options = {}) => {\n            this.wire.sendAction('layout-init').catch((e) => {\n                // don't expose\n            });\n            if (!this.wire.environment.layoutAllowedInContext(this.fin)) {\n                throw new Error('Layout.init can only be called from a Window context.');\n            }\n            if (__classPrivateFieldGet$3(this, _LayoutModule_layoutInitializationAttempted, \"f\")) {\n                throw new Error('Layout.init was already called, please use Layout.create to add additional layouts.');\n            }\n            if (this.wire.environment.type === 'openfin') {\n                // preload the client\n                await this.fin.Platform.getCurrentSync().getClient();\n            }\n            __classPrivateFieldSet$3(this, _LayoutModule_layoutInitializationAttempted, true, \"f\");\n            // TODO: rename to createLayoutManager\n            __classPrivateFieldSet$3(this, _LayoutModule_layoutManager, await this.wire.environment.initLayoutManager(this.fin, this.wire, options), \"f\");\n            await this.wire.environment.applyLayoutSnapshot(this.fin, __classPrivateFieldGet$3(this, _LayoutModule_layoutManager, \"f\"), options);\n            const meIdentity = { name: this.fin.me.name, uuid: this.fin.me.uuid };\n            if (!options.layoutManagerOverride) {\n                // CORE-1081 to be removed when we actually delete the `layoutManager` prop\n                // in single-layout case, we return the undocumented layoutManager type\n                const layoutIdentity = { layoutName: layout_constants_1.DEFAULT_LAYOUT_KEY, ...meIdentity };\n                return __classPrivateFieldGet$3(this, _LayoutModule_getLayoutManagerSpy, \"f\").call(this, layoutIdentity);\n            }\n            return this.wrapSync(meIdentity);\n        };\n        _LayoutModule_getLayoutManagerSpy.set(this, (layoutIdentity) => {\n            const msg = '[Layout] You are using a deprecated property `layoutManager` - it will throw if you access it starting in v37.';\n            const managerProxy = new Proxy({}, {\n                get(target, key) {\n                    console.warn(`[Layout-mgr-proxy] accessing ${key.toString()}`);\n                    throw new Error(msg);\n                }\n            });\n            const layout = Object.assign(this.wrapSync(layoutIdentity), { layoutManager: managerProxy });\n            const layoutProxy = new Proxy(layout, {\n                get(target, key) {\n                    if (key === 'layoutManager') {\n                        console.warn(`[Layout-proxy] accessing ${key.toString()}`);\n                        throw new Error(msg);\n                    }\n                    return target[key];\n                }\n            });\n            return layoutProxy;\n        });\n        /**\n         * Returns the layout manager for the current window\n         * @returns\n         */\n        this.getCurrentLayoutManagerSync = () => {\n            return __classPrivateFieldGet$3(this, _LayoutModule_instances, \"m\", _LayoutModule_getSafeLayoutManager).call(this, `fin.Platform.Layout.getCurrentLayoutManagerSync()`);\n        };\n        this.create = async (options) => {\n            return this.wire.environment.createLayout(__classPrivateFieldGet$3(this, _LayoutModule_instances, \"m\", _LayoutModule_getSafeLayoutManager).call(this, `fin.Platform.Layout.create()`), options);\n        };\n        this.destroy = async (layoutIdentity) => {\n            return this.wire.environment.destroyLayout(__classPrivateFieldGet$3(this, _LayoutModule_instances, \"m\", _LayoutModule_getSafeLayoutManager).call(this, `fin.Platform.Layout.destroy()`), layoutIdentity);\n        };\n    }\n    /**\n     * Asynchronously returns a Layout object that represents a Window's layout.\n     *\n     * @example\n     * ```js\n     * let windowIdentity;\n     * if (!fin.me.isWindow) {\n     *     windowIdentity = fin.me.identity;\n     * } else if (fin.me.isView) {\n     *     windowIdentity = (await fin.me.getCurrentWindow()).identity;\n     * } else {\n     *     throw new Error('Not running in a platform View or Window');\n     * }\n     *\n     * const layout = await fin.Platform.Layout.wrap(windowIdentity);\n     * // Use wrapped instance to control layout, e.g.:\n     * const layoutConfig = await layout.getConfig();\n     * ```\n     */\n    async wrap(identity) {\n        this.wire.sendAction('layout-wrap').catch((e) => {\n            // don't expose\n        });\n        return new Instance_1$2.Layout(identity, this.wire);\n    }\n    /**\n     * Synchronously returns a Layout object that represents a Window's layout.\n     *\n     * @example\n     * ```js\n     * let windowIdentity;\n     * if (!fin.me.isWindow) {\n     *     windowIdentity = fin.me.identity;\n     * } else if (fin.me.isView) {\n     *     windowIdentity = (await fin.me.getCurrentWindow()).identity;\n     * } else {\n     *     throw new Error('Not running in a platform View or Window');\n     * }\n     *\n     * const layout = fin.Platform.Layout.wrapSync(windowIdentity);\n     * // Use wrapped instance to control layout, e.g.:\n     * const layoutConfig = await layout.getConfig();\n     * ```\n     */\n    wrapSync(identity) {\n        this.wire.sendAction('layout-wrap-sync').catch((e) => {\n            // don't expose\n        });\n        return new Instance_1$2.Layout(identity, this.wire);\n    }\n    /**\n     * Asynchronously returns a Layout object that represents a Window's layout.\n     *\n     * @example\n     * ```js\n     * const layout = await fin.Platform.Layout.getCurrent();\n     * // Use wrapped instance to control layout, e.g.:\n     * const layoutConfig = await layout.getConfig();\n     * ```\n     */\n    async getCurrent() {\n        this.wire.sendAction('layout-get-current').catch((e) => {\n            // don't expose\n        });\n        if (!this.fin.me.isWindow) {\n            throw new Error('You are not in a Window context.  Only Windows can have a Layout.');\n        }\n        const { uuid, name } = this.fin.me;\n        return this.wrap({ uuid, name });\n    }\n    /**\n     * Synchronously returns a Layout object that represents a Window's layout.\n     *\n     * @remarks Cannot be called from a view.\n     *\n     *\n     * @example\n     * ```js\n     * const layout = fin.Platform.Layout.getCurrentSync();\n     * // Use wrapped instance to control layout, e.g.:\n     * const layoutConfig = await layout.getConfig();\n     * ```\n     */\n    getCurrentSync() {\n        this.wire.sendAction('layout-get-current-sync').catch((e) => {\n            // don't expose\n        });\n        if (!this.fin.me.isWindow) {\n            throw new Error('You are not in a Window context.  Only Windows can have a Layout.');\n        }\n        const { uuid, name } = this.fin.me;\n        return this.wrapSync({ uuid, name });\n    }\n}\nFactory$2.LayoutModule = LayoutModule;\n_LayoutModule_layoutInitializationAttempted = new WeakMap(), _LayoutModule_layoutManager = new WeakMap(), _LayoutModule_getLayoutManagerSpy = new WeakMap(), _LayoutModule_instances = new WeakSet(), _LayoutModule_getSafeLayoutManager = function _LayoutModule_getSafeLayoutManager(method) {\n    if (!__classPrivateFieldGet$3(this, _LayoutModule_layoutManager, \"f\")) {\n        throw new Error(`You must call init before using the API ${method}`);\n    }\n    return __classPrivateFieldGet$3(this, _LayoutModule_layoutManager, \"f\");\n};\n\n(function (exports) {\n\t/**\n\t * Entry point for the OpenFin `Layout` subset of the `Platform` API (`fin.Platform.Layout`).\n\t *\n\t * * {@link LayoutModule} contains static members of the `Layout` API, accessible through `fin.Platform.Layout`.\n\t * * {@link Layout} describes an instance of an OpenFin Layout, e.g. as returned by `fin.Platform.Layout.getCurrent`.\n\t *\n\t * These are separate code entities, and are documented separately. In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/32.114.76.10/index.html),\n\t * both of these were documented on the same page.\n\t *\n\t * @packageDocumentation\n\t *\n\t */\n\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t    }\n\t    Object.defineProperty(o, k2, desc);\n\t}) : (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    o[k2] = m[k];\n\t}));\n\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t};\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t__exportStar(Factory$2, exports);\n\t__exportStar(Instance$1, exports); \n} (layout));\n\nObject.defineProperty(Factory$3, \"__esModule\", { value: true });\nFactory$3.PlatformModule = void 0;\nconst base_1$3 = base;\nconst Instance_1$1 = Instance$2;\nconst index_1$1 = layout;\n/**\n * Static namespace for OpenFin API methods that interact with the {@link Platform} class, available under `fin.Platform`.\n */\nclass PlatformModule extends base_1$3.Base {\n    /**\n     * @internal\n     */\n    constructor(wire, channel) {\n        super(wire);\n        this._channel = channel;\n        /**\n         *\n         * @desc Layouts give app providers the ability to embed multiple views in a single window.  The Layout namespace\n         * enables the initialization and manipulation of a window's Layout.  A Layout will\n         * <a href=\"tutorial-Layout.DOMEvents.html\">emit events locally</a> on the DOM element representing the layout-container.\n         */\n        this.Layout = new index_1$1.LayoutModule(this.wire);\n    }\n    /**\n     * Initializes a Platform. Must be called from the Provider when using a custom provider.\n     * @param options - platform options including a callback function that can be used to extend or replace\n     * default Provider behavior.\n     *\n     * @remarks Must be called from the Provider when using a custom provider.\n     *\n     * @example\n     *\n     * ```js\n     * // From Provider context\n     * await fin.Platform.init();\n     * // Platform API is now hooked up and windows contained in the manifest snapshot are open.\n     * ```\n     *\n     * `Platform.init` accepts an options object that can contain a callback function which can be used to extend or\n     * replace default Provider behavior. As an argument, this function will receive the `Provider` class, which is\n     * used to handle Platform actions. The function must return an object with methods to handle Platform API actions.\n     * The recommended approach is to extend the `Provider` class, overriding the methods you wish to alter, and return an\n     * instance of your subclass:\n     *\n     * ```js\n     * const overrideCallback = async (PlatformProvider) => {\n     *     // Actions can be performed before initialization.\n     *     // e.g. we might authenticate a user, set up a Channel, etc before initializing the Platform.\n     *     const { manifestUrl } = await fin.Application.getCurrentSync().getInfo();\n     *\n     *     // Extend or replace default PlatformProvider behavior by extending the PlatformProvider class.\n     *     class MyOverride extends PlatformProvider {\n     *         // Default behavior can be changed by implementing methods with the same names as those used by the default PlatformProvider.\n     *         async getSnapshot() {\n     *             // Since we are extending the class, we can call `super` methods to access default behavior.\n     *             const snapshot = await super.getSnapshot();\n     *             // But we can modify return values.\n     *             return { ...snapshot, answer: 42, manifestUrl };\n     *         }\n     *         async replaceLayout({ opts, target }) {\n     *             // To disable an API method, overwrite with a noop function.\n     *             return;\n     *         }\n     *     }\n     *     // Return instance with methods to be consumed by Platform.\n     *     // The returned object must implement all methods of the PlatformProvider class.\n     *     // By extending the class, we can simply inherit methods we do not wish to alter.\n     *     return new MyOverride();\n     * };\n     *\n     * fin.Platform.init({overrideCallback});\n     * ```\n     * @experimental\n     */\n    async init(options) {\n        if (!fin.__internal_.isPlatform || fin.me.name !== fin.me.uuid) {\n            throw new Error('fin.Platform.init should only be called from a custom platform provider running in the main window of the application.');\n        }\n        return this.wire.environment.initPlatform(this.fin, options);\n    }\n    /**\n     * Asynchronously returns a Platform object that represents an existing platform.\n     *\n     * @example\n     * ```js\n     * const { identity } = fin.me;\n     * const platform = await fin.Platform.wrap(identity);\n     * // Use wrapped instance to control layout, e.g.:\n     * const snapshot = await platform.getSnapshot();\n     * ```\n     */\n    async wrap(identity) {\n        this.wire.sendAction('platform-wrap').catch((e) => {\n            // don't expose\n        });\n        return new Instance_1$1.Platform({ uuid: identity.uuid }, this._channel);\n    }\n    /**\n     * Synchronously returns a Platform object that represents an existing platform.\n     *\n     * @example\n     * ```js\n     * const { identity } = fin.me;\n     * const platform = fin.Platform.wrapSync(identity);\n     * // Use wrapped instance to control layout, e.g.:\n     * const snapshot = await platform.getSnapshot();\n     * ```\n     */\n    wrapSync(identity) {\n        this.wire.sendAction('platform-wrap-sync').catch((e) => {\n            // don't expose\n        });\n        return new Instance_1$1.Platform({ uuid: identity.uuid }, this._channel);\n    }\n    /**\n     * Asynchronously returns a Platform object that represents the current platform.\n     *\n     * @example\n     * ```js\n     * const platform = await fin.Platform.getCurrent();\n     * // Use wrapped instance to control layout, e.g.:\n     * const snapshot = await platform.getSnapshot();\n     * ```\n     */\n    async getCurrent() {\n        this.wire.sendAction('platform-get-current').catch((e) => {\n            // don't expose\n        });\n        return this.wrap({ uuid: this.wire.me.uuid });\n    }\n    /**\n     * Synchronously returns a Platform object that represents the current platform.\n     *\n     * @example\n     * ```js\n     * const platform = fin.Platform.getCurrentSync();\n     * // Use wrapped instance to control layout, e.g.:\n     * const snapshot = await platform.getSnapshot();\n     * ```\n     */\n    getCurrentSync() {\n        this.wire.sendAction('platform-get-current-sync').catch((e) => {\n            // don't expose\n        });\n        return this.wrapSync({ uuid: this.wire.me.uuid });\n    }\n    /**\n     * Creates and starts a Platform and returns a wrapped and running Platform instance. The wrapped Platform methods can\n     * be used to launch content into the platform.  Promise will reject if the platform is already running.\n     *\n     * @example\n     * ```js\n     * try {\n     *     const platform = await fin.Platform.start({\n     *         uuid: 'platform-1',\n     *         autoShow: false,\n     *         defaultWindowOptions: {\n     *             stylesheetUrl: 'css-sheet-url',\n     *             cornerRounding: {\n     *                 height: 10,\n     *                 width: 10\n     *             }\n     *         }\n     *     });\n     *     console.log('Platform is running', platform);\n     * } catch(e) {\n     *     console.error(e);\n     * }\n     * ```\n     */\n    start(platformOptions) {\n        this.wire.sendAction('platform-start').catch((e) => {\n            // don't expose\n        });\n        // eslint-disable-next-line no-async-promise-executor\n        return new Promise(async (resolve, reject) => {\n            try {\n                const { uuid } = platformOptions;\n                // @ts-expect-error using private variable.\n                const app = await this.fin.Application._create({ ...platformOptions, isPlatformController: true });\n                // TODO: fix typing (internal)\n                // @ts-expect-error\n                app.once('platform-api-ready', () => resolve(this.wrapSync({ uuid })));\n                // @ts-expect-error using private variable.\n                app._run({ uuid });\n            }\n            catch (e) {\n                reject(e);\n            }\n        });\n    }\n    /**\n     * Retrieves platforms's manifest and returns a wrapped and running Platform.  If there is a snapshot in the manifest,\n     * it will be launched into the platform.\n     * @param manifestUrl - The URL of platform's manifest.\n     * @param opts - Parameters that the RVM will use.\n     *\n     * @example\n     * ```js\n     * try {\n     *     const platform = await fin.Platform.startFromManifest('https://openfin.github.io/golden-prototype/public.json');\n     *     console.log('Platform is running, wrapped platform: ', platform);\n     * } catch(e) {\n     *     console.error(e);\n     * }\n     * // For a local manifest file:\n     * try {\n     *     const platform = await fin.Platform.startFromManifest('file:///C:/somefolder/app.json');\n     *     console.log('Platform is running, wrapped platform: ', platform);\n     * } catch(e) {\n     *     console.error(e);\n     * }\n     * ```\n     */\n    startFromManifest(manifestUrl, opts) {\n        this.wire.sendAction('platform-start-from-manifest').catch((e) => {\n            // don't expose\n        });\n        // eslint-disable-next-line no-async-promise-executor\n        return new Promise(async (resolve, reject) => {\n            try {\n                // @ts-expect-error using private variable.\n                const app = await this.fin.Application._createFromManifest(manifestUrl);\n                // TODO: fix typing (internal)\n                // @ts-expect-error\n                app.once('platform-api-ready', () => resolve(this.wrapSync({ uuid: app.identity.uuid })));\n                // @ts-expect-error using private method without warning.\n                app._run(opts);\n            }\n            catch (e) {\n                reject(e);\n            }\n        });\n    }\n}\nFactory$3.PlatformModule = PlatformModule;\n\n(function (exports) {\n\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t    }\n\t    Object.defineProperty(o, k2, desc);\n\t}) : (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    o[k2] = m[k];\n\t}));\n\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t};\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t/**\n\t * Entry points for the OpenFin `Platform` API (`fin.Platform`)\n\t *\n\t * * {@link PlatformModule} contains static members of the `Platform` API, accessible through `fin.Platform`.\n\t * * {@link Platform} describes an instance of an OpenFin Platform, e.g. as returned by `fin.Platform.getCurrent`.\n\t *\n\t * These are separate code entities, and are documented separately.  In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/32.114.76.10/index.html),\n\t * both of these were documented on the same page.\n\t *\n\t * @packageDocumentation\n\t */\n\t__exportStar(Factory$3, exports);\n\t__exportStar(Instance$2, exports); \n} (platform));\n\nvar me = {};\n\n(function (exports) {\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\texports.getMe = exports.getBaseMe = exports.environmentUnsupportedMessage = void 0;\n\tconst view_1 = requireView();\n\tconst frame_1 = frame;\n\tconst window_1 = requireWindow();\n\tconst external_application_1 = externalApplication;\n\texports.environmentUnsupportedMessage = 'You are not running in OpenFin.';\n\tfunction getBaseMe(entityType, uuid, name) {\n\t    const entityTypeHelpers = {\n\t        isView: entityType === 'view',\n\t        isWindow: entityType === 'window',\n\t        isFrame: entityType === 'iframe',\n\t        isExternal: entityType === 'external connection'\n\t    };\n\t    return { ...entityTypeHelpers, uuid, name, entityType };\n\t}\n\texports.getBaseMe = getBaseMe;\n\t// We need to do a lot of casting as unknown here because the compiler get's confused about matching types. What matters is that it works on the outside\n\tfunction getMe(wire) {\n\t    const { uuid, name, entityType } = wire.me;\n\t    const unsupportedInterop = {\n\t        setContext() {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        addContextHandler() {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        getContextGroups() {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        joinContextGroup() {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        removeFromContextGroup() {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        getAllClientsInContextGroup() {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        getInfoForContextGroup() {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        }\n\t    };\n\t    const fallbackErrorMessage = 'Interop API has not been instantiated. Either connection has failed or you have not declared interop in your config.';\n\t    const fallbackInterop = {\n\t        setContext() {\n\t            throw new Error(fallbackErrorMessage);\n\t        },\n\t        addContextHandler() {\n\t            throw new Error(fallbackErrorMessage);\n\t        },\n\t        getContextGroups() {\n\t            throw new Error(fallbackErrorMessage);\n\t        },\n\t        joinContextGroup() {\n\t            throw new Error(fallbackErrorMessage);\n\t        },\n\t        removeFromContextGroup() {\n\t            throw new Error(fallbackErrorMessage);\n\t        },\n\t        getAllClientsInContextGroup() {\n\t            throw new Error(fallbackErrorMessage);\n\t        },\n\t        getInfoForContextGroup() {\n\t            throw new Error(fallbackErrorMessage);\n\t        }\n\t    };\n\t    const unsupportedEventBase = {\n\t        eventNames: () => {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        emit: () => {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        listeners: () => {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        listenerCount: () => {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        on: () => {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        addListener: () => {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        once: () => {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        prependListener: () => {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        prependOnceListener: () => {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        removeListener: () => {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        },\n\t        removeAllListeners: () => {\n\t            throw new Error(exports.environmentUnsupportedMessage);\n\t        }\n\t    };\n\t    switch (entityType) {\n\t        case 'view':\n\t            return Object.assign(new view_1.View(wire, { uuid, name }), getBaseMe(entityType, uuid, name), {\n\t                interop: fallbackInterop,\n\t                isOpenFin: true\n\t            });\n\t        case 'window':\n\t            return Object.assign(new window_1._Window(wire, { uuid, name }), getBaseMe(entityType, uuid, name), {\n\t                interop: fallbackInterop,\n\t                isOpenFin: true\n\t            });\n\t        case 'iframe':\n\t            return Object.assign(new frame_1._Frame(wire, { uuid, name }), getBaseMe(entityType, uuid, name), {\n\t                interop: fallbackInterop,\n\t                isOpenFin: true\n\t            });\n\t        case 'external connection':\n\t            return Object.assign(new external_application_1.ExternalApplication(wire, { uuid }), getBaseMe(entityType, uuid, name), {\n\t                interop: fallbackInterop,\n\t                isOpenFin: false\n\t            });\n\t        default:\n\t            return {\n\t                ...getBaseMe(entityType, uuid, name),\n\t                ...unsupportedEventBase,\n\t                interop: unsupportedInterop,\n\t                isOpenFin: false\n\t            };\n\t    }\n\t}\n\texports.getMe = getMe; \n} (me));\n\nvar interop = {};\n\nvar Factory$1 = {};\n\nvar inaccessibleObject = {};\n\nObject.defineProperty(inaccessibleObject, \"__esModule\", { value: true });\ninaccessibleObject.createWarningObject = inaccessibleObject.createUnusableObject = void 0;\nfunction createUnusableObject(message) {\n    const handle = () => {\n        throw new Error(message);\n    };\n    return new Proxy({}, {\n        apply: handle,\n        construct: handle,\n        defineProperty: handle,\n        deleteProperty: handle,\n        get: handle,\n        getOwnPropertyDescriptor: handle,\n        getPrototypeOf: handle,\n        has: handle,\n        isExtensible: handle,\n        ownKeys: handle,\n        preventExtensions: handle,\n        set: handle,\n        setPrototypeOf: handle\n    });\n}\ninaccessibleObject.createUnusableObject = createUnusableObject;\nfunction createWarningObject(message, obj) {\n    return new Proxy(obj, {\n        get: (...args) => {\n            // eslint-disable-next-line no-console\n            console.warn(message);\n            return Reflect.get(...args);\n        },\n        set: (...args) => {\n            // eslint-disable-next-line no-console\n            console.warn(message);\n            return Reflect.set(...args);\n        },\n        getOwnPropertyDescriptor: (...args) => {\n            // eslint-disable-next-line no-console\n            console.warn(message);\n            return Reflect.getOwnPropertyDescriptor(...args);\n        },\n        ownKeys: (...args) => {\n            // eslint-disable-next-line no-console\n            console.warn(message);\n            return Reflect.ownKeys(...args);\n        }\n    });\n}\ninaccessibleObject.createWarningObject = createWarningObject;\n\nvar InteropBroker = {};\n\nvar SessionContextGroupBroker = {};\n\nvar hasRequiredSessionContextGroupBroker;\n\nfunction requireSessionContextGroupBroker () {\n\tif (hasRequiredSessionContextGroupBroker) return SessionContextGroupBroker;\n\thasRequiredSessionContextGroupBroker = 1;\n\tObject.defineProperty(SessionContextGroupBroker, \"__esModule\", { value: true });\n\tconst _1 = requireInterop();\n\tlet SessionContextGroupBroker$1 = class SessionContextGroupBroker {\n\t    constructor(provider, id) {\n\t        this.provider = provider;\n\t        this.id = id;\n\t        this.lastContext = undefined;\n\t        this.contextGroupMap = new Map();\n\t        this.clients = new Map();\n\t        this.registerListeners();\n\t    }\n\t    registerListeners() {\n\t        this.provider.register(`sessionContextGroup:getContext-${this.id}`, this.getCurrentContext.bind(this));\n\t        this.provider.register(`sessionContextGroup:setContext-${this.id}`, this.setContext.bind(this));\n\t        this.provider.register(`sessionContextGroup:handlerAdded-${this.id}`, this.handlerAdded.bind(this));\n\t        this.provider.register(`sessionContextGroup:handlerRemoved-${this.id}`, this.handlerRemoved.bind(this));\n\t    }\n\t    getCurrentContext(payload) {\n\t        return payload.type ? this.contextGroupMap.get(payload.type) : this.lastContext;\n\t    }\n\t    setContext(payload, clientIdentity) {\n\t        const { context } = payload;\n\t        const contextIntegrityCheckResult = _1.InteropBroker.checkContextIntegrity(context);\n\t        if (contextIntegrityCheckResult.isValid === false) {\n\t            throw new Error(`Failed to set Context - bad Context. Reason: ${contextIntegrityCheckResult.reason}. Context: ${JSON.stringify(context)}`);\n\t        }\n\t        const clientState = this.getClientState(clientIdentity);\n\t        if (!clientState) {\n\t            // This shouldn't get hit.\n\t            throw new Error(`Client with Identity: ${clientIdentity.uuid} ${clientIdentity.name} not in Session Client State Map`);\n\t        }\n\t        // set the context\n\t        this.contextGroupMap.set(context.type, context);\n\t        this.lastContext = context;\n\t        const clientSubscriptionStates = Array.from(this.clients.values());\n\t        clientSubscriptionStates.forEach((client) => {\n\t            // eslint-disable-next-line no-unused-expressions\n\t            client.contextHandlers.get(context.type)?.forEach((handlerId) => {\n\t                this.provider.dispatch(client.clientIdentity, handlerId, context);\n\t            });\n\t            if (client.globalHandler) {\n\t                this.provider.dispatch(client.clientIdentity, client.globalHandler, context);\n\t            }\n\t        });\n\t    }\n\t    getClientState(id) {\n\t        return this.clients.get(id.endpointId);\n\t    }\n\t    async handlerAdded(payload, clientIdentity) {\n\t        const { handlerId, contextType } = payload;\n\t        const clientSubscriptionState = this.getClientState(clientIdentity);\n\t        if (!clientSubscriptionState) {\n\t            throw new Error(`Client with Identity: ${clientIdentity.uuid} ${clientIdentity.name} not in Client State Map`);\n\t        }\n\t        if (contextType) {\n\t            const currentHandlerList = clientSubscriptionState.contextHandlers.get(contextType) || [];\n\t            clientSubscriptionState.contextHandlers.set(contextType, [...currentHandlerList, handlerId]);\n\t            const currentContext = this.contextGroupMap.get(contextType);\n\t            if (currentContext) {\n\t                await this.provider.dispatch(clientIdentity, handlerId, currentContext);\n\t            }\n\t        }\n\t        else {\n\t            clientSubscriptionState.globalHandler = handlerId;\n\t            const globalDispatchPromises = [...this.contextGroupMap.keys()].map(async (currentContextType) => {\n\t                const currentContext = this.contextGroupMap.get(currentContextType);\n\t                if (currentContext) {\n\t                    await this.provider.dispatch(clientIdentity, handlerId, currentContext);\n\t                }\n\t            });\n\t            await Promise.all(globalDispatchPromises);\n\t        }\n\t    }\n\t    handlerRemoved(payload, clientIdentity) {\n\t        const { handlerId } = payload;\n\t        const client = this.clients.get(clientIdentity.endpointId);\n\t        if (client) {\n\t            Array.from(client.contextHandlers).forEach(([, handlers]) => {\n\t                const index = handlers.indexOf(handlerId);\n\t                if (index > -1) {\n\t                    handlers.splice(index, 1);\n\t                }\n\t            });\n\t            if (client.globalHandler === handlerId) {\n\t                client.globalHandler = undefined;\n\t            }\n\t        }\n\t        else {\n\t            console.warn(`Trying to remove a handler from a client that isn't mapped. handlerId: ${handlerId}. clientIdentity: ${clientIdentity}`);\n\t        }\n\t    }\n\t    registerNewClient(clientIdentity) {\n\t        if (!this.clients.has(clientIdentity.endpointId)) {\n\t            const clientSubscriptionState = {\n\t                contextHandlers: new Map(),\n\t                clientIdentity,\n\t                globalHandler: undefined\n\t            };\n\t            this.clients.set(clientIdentity.endpointId, clientSubscriptionState);\n\t        }\n\t    }\n\t    onDisconnection(clientIdentity) {\n\t        this.clients.delete(clientIdentity.endpointId);\n\t    }\n\t};\n\tSessionContextGroupBroker.default = SessionContextGroupBroker$1;\n\treturn SessionContextGroupBroker;\n}\n\nvar utils$3 = {};\n\n(function (exports) {\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\texports.wrapIntentHandler = exports.BROKER_ERRORS = exports.generateOverrideWarning = exports.generateOverrideError = exports.wrapContextHandler = exports.wrapInTryCatch = exports.generateId = void 0;\n\tconst generateId = () => `${Math.random()}${Date.now()}`;\n\texports.generateId = generateId;\n\tconst wrapInTryCatch = (f, prefix) => (...args) => {\n\t    try {\n\t        return f(...args);\n\t    }\n\t    catch (e) {\n\t        throw new Error((prefix || '') + e);\n\t    }\n\t};\n\texports.wrapInTryCatch = wrapInTryCatch;\n\tconst wrapContextHandler = (handler, handlerId) => {\n\t    return async (context) => {\n\t        try {\n\t            await handler(context);\n\t        }\n\t        catch (error) {\n\t            console.error(`Error thrown by handler ${handlerId} for context type ${context.type}: ${error}`);\n\t            throw error;\n\t        }\n\t    };\n\t};\n\texports.wrapContextHandler = wrapContextHandler;\n\tconst generateOverrideError = (clientApi, brokerApi) => {\n\t    return `You have tried to to use ${clientApi} but ${brokerApi} has not been overridden in the Interop Broker. Please override this function. Refer to our documentation for more info.`;\n\t};\n\texports.generateOverrideError = generateOverrideError;\n\tconst generateOverrideWarning = (fdc3ClientApi, brokerApi, identity, interopClientApi) => {\n\t    const { uuid, name } = identity;\n\t    const message = interopClientApi\n\t        ? `Entity with identity: ${uuid}/${name} has called ${interopClientApi} or ${fdc3ClientApi} but ${brokerApi} has not been overridden.`\n\t        : `Entity with identity: ${uuid}/${name} has called ${fdc3ClientApi} but ${brokerApi} has not been overridden.`;\n\t    return message;\n\t};\n\texports.generateOverrideWarning = generateOverrideWarning;\n\texports.BROKER_ERRORS = {\n\t    fireIntent: (0, exports.generateOverrideError)('fireIntent', 'handleFiredIntent'),\n\t    fireIntentForContext: (0, exports.generateOverrideError)('fireIntentForContext', 'handleFiredIntentForContext'),\n\t    getInfoForIntent: (0, exports.generateOverrideError)('getInfoForIntent', 'handleInfoForIntent'),\n\t    getInfoForIntentsByContext: (0, exports.generateOverrideError)('getInfoForIntentsByContext', 'handleInfoForIntentsByContext'),\n\t    joinSessionContextGroupWithJoinContextGroup: 'The Context Group you have tried to join is a Session Context Group. Custom Context Groups can only be defined by the Interop Broker through code or manifest configuration. Please use joinSessionContextGroup.',\n\t    fdc3Open: (0, exports.generateOverrideError)('fdc3.open', 'fdc3HandleOpen'),\n\t    fdc3FindInstances: (0, exports.generateOverrideError)('fdc3.findInstances', 'fdc3HandleFindInstances'),\n\t    fdc3GetAppMetadata: (0, exports.generateOverrideError)('fdc3.getAppMetadata', 'fdc3HandleGetAppMetadata'),\n\t    fdc3GetInfo: (0, exports.generateOverrideError)('fdc3.getInfo', 'fdc3HandleGetInfo')\n\t};\n\tconst wrapIntentHandler = (handler, handlerId) => {\n\t    return async (intent) => {\n\t        try {\n\t            return handler(intent);\n\t        }\n\t        catch (error) {\n\t            console.error(`Error thrown by handler ${handlerId}: ${error}`);\n\t            throw error;\n\t        }\n\t    };\n\t};\n\texports.wrapIntentHandler = wrapIntentHandler; \n} (utils$3));\n\nvar PrivateChannelProvider = {};\n\nvar hasRequiredPrivateChannelProvider;\n\nfunction requirePrivateChannelProvider () {\n\tif (hasRequiredPrivateChannelProvider) return PrivateChannelProvider;\n\thasRequiredPrivateChannelProvider = 1;\n\tObject.defineProperty(PrivateChannelProvider, \"__esModule\", { value: true });\n\tPrivateChannelProvider.PrivateChannelProvider = void 0;\n\tconst InteropBroker_1 = requireInteropBroker();\n\tlet PrivateChannelProvider$1 = class PrivateChannelProvider {\n\t    constructor(provider, id) {\n\t        this.provider = provider;\n\t        this.id = id;\n\t        this.clients = new Map();\n\t        this.registerListeners();\n\t        this.contextByContextType = new Map();\n\t        this.lastContext = undefined;\n\t        this.provider.onConnection((clientIdentity) => this.registerNewClient(clientIdentity));\n\t        this.provider.onDisconnection(async (clientIdentity) => {\n\t            const { endpointId } = clientIdentity;\n\t            if (this.clients.has(endpointId)) {\n\t                await this.handleClientDisconnecting(clientIdentity);\n\t            }\n\t            if ((await this.provider.getAllClientInfo()).length === 0) {\n\t                this.provider.destroy();\n\t            }\n\t        });\n\t    }\n\t    getClientState(id) {\n\t        return this.clients.get(id.endpointId);\n\t    }\n\t    registerListeners() {\n\t        this.provider.register('broadcast', this.broadcast.bind(this));\n\t        this.provider.register('getCurrentContext', this.getCurrentContext.bind(this));\n\t        this.provider.register('contextHandlerAdded', this.contextHandlerAdded.bind(this));\n\t        this.provider.register('contextHandlerRemoved', this.contextHandlerRemoved.bind(this));\n\t        this.provider.register('nonStandardHandlerRemoved', this.nonStandardHandlerRemoved.bind(this));\n\t        this.provider.register('onAddContextHandlerAdded', this.onAddContextHandlerAdded.bind(this));\n\t        this.provider.register('onDisconnectHandlerAdded', this.onDisconnectHandlerAdded.bind(this));\n\t        this.provider.register('onUnsubscribeHandlerAdded', this.onUnsubscribeHandlerAdded.bind(this));\n\t        this.provider.register('clientDisconnecting', (payload, clientIdentity) => {\n\t            this.handleClientDisconnecting(clientIdentity);\n\t        });\n\t    }\n\t    broadcast(payload, broadcasterClientIdentity) {\n\t        const { context } = payload;\n\t        const broadcasterClientState = this.getClientState(broadcasterClientIdentity);\n\t        if (!broadcasterClientState) {\n\t            throw new Error(`Client with Identity: ${broadcasterClientIdentity.uuid} ${broadcasterClientIdentity.name}, tried to call broadcast, is not connected to this Private Channel`);\n\t        }\n\t        const contextIntegrityCheckResult = InteropBroker_1.InteropBroker.checkContextIntegrity(context);\n\t        if (contextIntegrityCheckResult.isValid === false) {\n\t            throw new Error(`Failed to broadcast - bad Context. Reason: ${contextIntegrityCheckResult.reason}. Context: ${JSON.stringify(context)}`);\n\t        }\n\t        this.contextByContextType.set(context.type, context);\n\t        this.lastContext = context;\n\t        Array.from(this.clients.values()).forEach((currClientState) => {\n\t            const handlerIdsForContextType = currClientState.handlerIdsByContextTypes.get(context.type);\n\t            if (handlerIdsForContextType) {\n\t                handlerIdsForContextType.forEach((handlerId) => {\n\t                    this.provider.dispatch(currClientState.clientIdentity, handlerId, context);\n\t                });\n\t            }\n\t            if (currClientState.globalHandler) {\n\t                this.provider.dispatch(currClientState.clientIdentity, currClientState.globalHandler, context);\n\t            }\n\t        });\n\t    }\n\t    getCurrentContext(payload, senderClientIdentity) {\n\t        const { contextType } = payload;\n\t        const clientState = this.getClientState(senderClientIdentity);\n\t        if (!clientState) {\n\t            throw new Error(`Client with Identity: ${senderClientIdentity.uuid} ${senderClientIdentity.name}, tried to call getCurrentContext, is not connected to this Private Channel`);\n\t        }\n\t        if (contextType !== undefined) {\n\t            const currentContext = this.contextByContextType.get(contextType);\n\t            if (currentContext)\n\t                return currentContext;\n\t            return null;\n\t        }\n\t        return this.lastContext ? this.lastContext : null;\n\t    }\n\t    contextHandlerAdded(payload, senderClientIdentity) {\n\t        const { handlerId, contextType } = payload;\n\t        const senderClientState = this.getClientState(senderClientIdentity);\n\t        if (!senderClientState) {\n\t            throw new Error(`Client with Identity: ${senderClientIdentity.uuid} ${senderClientIdentity.name}, tried to call addContextListener, is not connected to this Private Channel`);\n\t        }\n\t        if (contextType) {\n\t            const currentHandlersList = senderClientState.handlerIdsByContextTypes.get(contextType) || [];\n\t            senderClientState.handlerIdsByContextTypes.set(contextType, [...currentHandlersList, handlerId]);\n\t        }\n\t        else {\n\t            senderClientState.globalHandler = handlerId;\n\t        }\n\t        Array.from(this.clients.values()).forEach((currClientState) => {\n\t            if (currClientState.clientIdentity.endpointId !== senderClientIdentity.endpointId &&\n\t                currClientState.onAddContextListenerHandlerId) {\n\t                this.provider.dispatch(currClientState.clientIdentity, currClientState.onAddContextListenerHandlerId, contextType);\n\t            }\n\t        });\n\t    }\n\t    async contextHandlerRemoved(payload, removingClientIdentity) {\n\t        // MC: Made this removal async to ensure that onUnsubscribe handlers are hit before anything else happens.\n\t        const { handlerId } = payload;\n\t        const removingClientState = this.getClientState(removingClientIdentity);\n\t        if (removingClientState) {\n\t            let contextType;\n\t            if (removingClientState.globalHandler === handlerId) {\n\t                removingClientState.globalHandler = undefined;\n\t            }\n\t            else {\n\t                for (const [currContextType, handlersIds] of removingClientState.handlerIdsByContextTypes) {\n\t                    const index = handlersIds.indexOf(handlerId);\n\t                    if (index > -1) {\n\t                        handlersIds.splice(index, 1);\n\t                        contextType = currContextType;\n\t                    }\n\t                }\n\t            }\n\t            // getting only valid client connections here, it is possible we haven't removed a disconnected client from the map yet\n\t            // so we need to ensure we don't dispatch to any disconnected client\n\t            // TODO: Take a look at our client disconnection logic and see if we can handle client disconnection cleanly\n\t            const clientsToDispatchTo = await this.getConnectedClients();\n\t            const dispatchPromises = clientsToDispatchTo.map(async (otherClientState) => {\n\t                const { clientIdentity, clientIdentity: { endpointId }, onUnsubscribeHandlerId } = otherClientState;\n\t                if (endpointId !== removingClientIdentity.endpointId && onUnsubscribeHandlerId) {\n\t                    await this.provider.dispatch(clientIdentity, onUnsubscribeHandlerId, contextType);\n\t                }\n\t            });\n\t            try {\n\t                await Promise.all(dispatchPromises);\n\t            }\n\t            catch (error) {\n\t                console.error(`Problem when attempting to dispatch to onUnsubscribeHandlers. Error: ${error} Removing Client: ${handlerId}. uuid: ${removingClientIdentity.uuid}. name: ${removingClientIdentity.name}. endpointId: ${removingClientIdentity.endpointId}`);\n\t                throw new Error(error);\n\t            }\n\t        }\n\t        else {\n\t            console.warn(`Trying to remove a handler from a client that isn't mapped. handlerId: ${handlerId}. uuid: ${removingClientIdentity.uuid}. name: ${removingClientIdentity.name}. endpointId: ${removingClientIdentity.endpointId}.`);\n\t        }\n\t    }\n\t    nonStandardHandlerRemoved(payload, id) {\n\t        const { handlerId } = payload;\n\t        const clientState = this.getClientState(id);\n\t        if (clientState) {\n\t            if (clientState.onDisconnectHandlerId === handlerId) {\n\t                clientState.onDisconnectHandlerId = undefined;\n\t            }\n\t            else if (clientState.onAddContextListenerHandlerId === handlerId) {\n\t                clientState.onAddContextListenerHandlerId = undefined;\n\t            }\n\t            else if (clientState.onUnsubscribeHandlerId === handlerId) {\n\t                clientState.onUnsubscribeHandlerId = undefined;\n\t            }\n\t        }\n\t        else {\n\t            console.warn(`Trying to remove a handler from a client that isn't mapped. handlerId: ${handlerId}. clientIdentity: ${id}`);\n\t        }\n\t    }\n\t    onAddContextHandlerAdded(payload, senderClientIdentity) {\n\t        const clientState = this.getClientState(senderClientIdentity);\n\t        const { handlerId } = payload;\n\t        if (!clientState) {\n\t            throw new Error(`Client with Identity: ${senderClientIdentity.uuid} ${senderClientIdentity.name}, tried to call onAddContextListener, is not connected to this Private Channel`);\n\t        }\n\t        clientState.onAddContextListenerHandlerId = handlerId;\n\t        // FDC3 Spec says that the added listener should fire for all previously-registered addContextListeners from the other client\n\t        Array.from(this.clients.values()).forEach((otherClientState) => {\n\t            if (otherClientState.clientIdentity.endpointId !== senderClientIdentity.endpointId) {\n\t                Array.from(otherClientState.handlerIdsByContextTypes.keys()).forEach((subscribedContextType) => {\n\t                    this.provider.dispatch(senderClientIdentity, handlerId, subscribedContextType);\n\t                });\n\t            }\n\t        });\n\t    }\n\t    onDisconnectHandlerAdded(payload, id) {\n\t        const clientState = this.getClientState(id);\n\t        const { handlerId } = payload;\n\t        if (!clientState) {\n\t            throw new Error(`Client with Identity: ${id.uuid} ${id.name}, tried to call onDisconnect, is not connected to this Private Channel`);\n\t        }\n\t        clientState.onDisconnectHandlerId = handlerId;\n\t    }\n\t    onUnsubscribeHandlerAdded(payload, id) {\n\t        const clientState = this.getClientState(id);\n\t        const { handlerId } = payload;\n\t        if (!clientState) {\n\t            throw new Error(`Client with Identity: ${id.uuid} ${id.name}, tried to call onUnsubscribe, is not connected to this Private Channel`);\n\t        }\n\t        clientState.onUnsubscribeHandlerId = handlerId;\n\t    }\n\t    removeClient(disconnectingClientIdentity) {\n\t        const disconnectingClientState = this.getClientState(disconnectingClientIdentity);\n\t        if (!disconnectingClientState) {\n\t            throw new Error(`Client with Identity: ${disconnectingClientIdentity.uuid} ${disconnectingClientIdentity.name}, tried to call disconnect, is not connected to this Private Channel`);\n\t        }\n\t        disconnectingClientState.handlerIdsByContextTypes.clear();\n\t        this.clients.delete(disconnectingClientIdentity.endpointId);\n\t    }\n\t    async fireOnDisconnectForOtherClients(disconnectingClientIdentity) {\n\t        // TODO: call onDisconnect Handler of the other client only.\n\t        // CURRENTLY, just calling the onDisconnect handler for all the other clients. Once we limit it to just one other client, we can eliminate all the iteration code.\n\t        const { endpointId } = disconnectingClientIdentity;\n\t        // getting only valid client connections here, it is possible we haven't removed a disconnected client from the map yet\n\t        // so we need to ensure we don't dispatch to any disconnected client\n\t        // TODO: Take a look at our client disconnection logic and see if we can handle client disconnection cleanly\n\t        const clientsToDispatchTo = await this.getConnectedClients();\n\t        const dispatchPromises = clientsToDispatchTo.map(async (otherClientState) => {\n\t            const { clientIdentity: { endpointId: otherClientEndpointId }, onDisconnectHandlerId } = otherClientState;\n\t            if (otherClientEndpointId !== endpointId && onDisconnectHandlerId) {\n\t                await this.provider.dispatch(otherClientState.clientIdentity, onDisconnectHandlerId);\n\t            }\n\t        });\n\t        try {\n\t            await Promise.all(dispatchPromises);\n\t        }\n\t        catch (error) {\n\t            console.error(`Problem when attempting to dispatch to onDisconnectHandlers. Error: ${error} Disconnecting Client: uuid: ${disconnectingClientIdentity.uuid}. name: ${disconnectingClientIdentity.name}. endpointId: ${disconnectingClientIdentity.endpointId}`);\n\t            throw new Error(error);\n\t        }\n\t    }\n\t    async unsubscribeAll(clientIdentity) {\n\t        const { endpointId } = clientIdentity;\n\t        const state = this.clients.get(endpointId);\n\t        if (state) {\n\t            const contextTypeHandlerIds = Array.from(state.handlerIdsByContextTypes.values()).flat();\n\t            const globalHandlerId = state.globalHandler;\n\t            if (contextTypeHandlerIds.length > 0) {\n\t                const unsubPromises = contextTypeHandlerIds.map(async (handlerId) => {\n\t                    return this.contextHandlerRemoved({ handlerId }, clientIdentity);\n\t                });\n\t                try {\n\t                    await Promise.all(unsubPromises);\n\t                }\n\t                catch (error) {\n\t                    console.error(error.message);\n\t                }\n\t            }\n\t            if (globalHandlerId) {\n\t                try {\n\t                    await this.contextHandlerRemoved({ handlerId: globalHandlerId }, clientIdentity);\n\t                }\n\t                catch (error) {\n\t                    console.error(error.message);\n\t                }\n\t            }\n\t        }\n\t    }\n\t    async handleClientDisconnecting(disconnectingClientIdentity) {\n\t        await this.unsubscribeAll(disconnectingClientIdentity);\n\t        this.removeClient(disconnectingClientIdentity);\n\t        await this.fireOnDisconnectForOtherClients(disconnectingClientIdentity);\n\t    }\n\t    registerNewClient(clientIdentity) {\n\t        if (!this.clients.has(clientIdentity.endpointId)) {\n\t            const clientSubscriptionState = {\n\t                clientIdentity,\n\t                handlerIdsByContextTypes: new Map(),\n\t                globalHandler: undefined,\n\t                onAddContextListenerHandlerId: undefined,\n\t                onUnsubscribeHandlerId: undefined,\n\t                onDisconnectHandlerId: undefined\n\t            };\n\t            this.clients.set(clientIdentity.endpointId, clientSubscriptionState);\n\t        }\n\t    }\n\t    async getConnectedClients() {\n\t        const allClientInfo = await this.provider.getAllClientInfo();\n\t        return Array.from(this.clients.values()).filter((clientState) => {\n\t            const { uuid, name } = clientState.clientIdentity;\n\t            return allClientInfo.some((clientInfo) => {\n\t                return name === clientInfo.name && uuid === clientInfo.uuid;\n\t            });\n\t        });\n\t    }\n\t    static init(channelProvider, id) {\n\t        return new PrivateChannelProvider(channelProvider, id);\n\t    }\n\t};\n\tPrivateChannelProvider.PrivateChannelProvider = PrivateChannelProvider$1;\n\treturn PrivateChannelProvider;\n}\n\nvar hasRequiredInteropBroker;\n\nfunction requireInteropBroker () {\n\tif (hasRequiredInteropBroker) return InteropBroker;\n\thasRequiredInteropBroker = 1;\n\tvar __classPrivateFieldSet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n\t    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n\t    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n\t    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n\t    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n\t};\n\tvar __classPrivateFieldGet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n\t    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n\t    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n\t    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n\t};\n\tvar __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {\n\t    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n\t};\n\tvar _InteropBroker_fdc3Info, _InteropBroker_contextGroups, _InteropBroker_providerPromise;\n\tObject.defineProperty(InteropBroker, \"__esModule\", { value: true });\n\tInteropBroker.InteropBroker = void 0;\n\tconst base_1 = base;\n\tconst SessionContextGroupBroker_1 = __importDefault(requireSessionContextGroupBroker());\n\tconst utils_1 = utils$3;\n\tconst isEqual_1 = __importDefault(require$$3);\n\tconst PrivateChannelProvider_1 = requirePrivateChannelProvider();\n\tconst lazy_1 = lazy;\n\tconst defaultContextGroups = [\n\t    {\n\t        id: 'green',\n\t        displayMetadata: {\n\t            color: '#00CC88',\n\t            name: 'green'\n\t        }\n\t    },\n\t    {\n\t        id: 'purple',\n\t        displayMetadata: {\n\t            color: '#8C61FF',\n\t            name: 'purple'\n\t        }\n\t    },\n\t    {\n\t        id: 'orange',\n\t        displayMetadata: {\n\t            color: '#FF8C4C',\n\t            name: 'orange'\n\t        }\n\t    },\n\t    {\n\t        id: 'red',\n\t        displayMetadata: {\n\t            color: '#FF5E60',\n\t            name: 'red'\n\t        }\n\t    },\n\t    {\n\t        id: 'pink',\n\t        displayMetadata: {\n\t            color: '#FF8FB8',\n\t            name: 'pink'\n\t        }\n\t    },\n\t    {\n\t        id: 'yellow',\n\t        displayMetadata: {\n\t            color: '#E9FF8F',\n\t            name: 'yellow'\n\t        }\n\t    }\n\t];\n\t/**\n\t * {@link https://developers.openfin.co/of-docs/docs/enable-color-linking}\n\t *\n\t * The Interop Broker is responsible for keeping track of the Interop state of the Platform, and for directing messages to the proper locations.\n\t *\n\t * @remarks This class contains some types related to FDC3 that are specific to OpenFin. {@link https://developers.openfin.co/of-docs/docs/fdc3-support-in-openfin OpenFin's FDC3 support} is forward- and backward-compatible.\n\t * Standard types for {@link https://fdc3.finos.org/ FDC3} do not appear in OpenFin’s API documentation, to avoid duplication.\n\t *\n\t * ---\n\t *\n\t * There are 2 ways to inject custom functionality into the Interop Broker:\n\t *\n\t * **1. Configuration**\n\t *\n\t * At the moment, you can configure the default context groups for the Interop Broker without having to override it. To do so, include the `interopBrokerConfiguration` `contextGroups` option in your `platform` options in your manifest. This is the preferred method.\n\t * ```js\n\t * {\n\t *      \"runtime\": {\n\t *          \"arguments\": \"--v=1 --inspect\",\n\t *          \"version\": \"alpha-v19\"\n\t *      },\n\t *      \"platform\": {\n\t *          \"uuid\": \"platform_customization_local\",\n\t *          \"applicationIcon\": \"https://openfin.github.io/golden-prototype/favicon.ico\",\n\t *          \"autoShow\": false,\n\t *          \"providerUrl\": \"http://localhost:5555/provider.html\",\n\t *          \"interopBrokerConfiguration\": {\n\t *              \"contextGroups\": [\n\t *                  {\n\t *                      \"id\": \"green\",\n\t *                      \"displayMetadata\": {\n\t *                          \"color\": \"#00CC88\",\n\t *                          \"name\": \"green\"\n\t *                      }\n\t *                  },\n\t *                  {\n\t *                      \"id\": \"purple\",\n\t *                      \"displayMetadata\": {\n\t *                          \"color\": \"#8C61FF\",\n\t *                          \"name\": \"purple\"\n\t *                      }\n\t *                  },\n\t *              ]\n\t *          }\n\t *      }\n\t * }\n\t * ```\n\t *\n\t * By default the Interop Broker logs all actions to the console. You can disable this by using the logging option in `interopBrokerConfiguration`:\n\t * ```js\n\t * {\n\t *      \"runtime\": {\n\t *          \"arguments\": \"--v=1 --inspect\",\n\t *          \"version\": \"alpha-v19\"\n\t *      },\n\t *      \"platform\": {\n\t *          \"uuid\": \"platform_customization_local\",\n\t *          \"applicationIcon\": \"https://openfin.github.io/golden-prototype/favicon.ico\",\n\t *          \"autoShow\": false,\n\t *          \"providerUrl\": \"http://localhost:5555/provider.html\",\n\t *\t\t    \"interopBrokerConfiguration\": {\n\t *       \t\t\"logging\": {\n\t *   \t\t\t\t\"beforeAction\": {\n\t *   \t\t\t\t\t\"enabled\": false\n\t *   \t\t\t\t},\n\t *   \t\t\t\t\"afterAction\": {\n\t *   \t\t\t\t\t\"enabled\": false\n\t *   \t\t\t\t}\n\t *   \t\t\t}\n\t *\t\t    }\n\t *      }\n\t * }\n\t * ```\n\t *\n\t * ---\n\t * **2. Overriding**\n\t *\n\t * Similarly to how {@link https://developers.openfin.co/docs/platform-customization#section-customizing-platform-behavior Platform Overriding} works, you can override functions in the Interop Broker in `fin.Platform.init`. An example of that is shown below. Overriding `isConnectionAuthorized` and `isActionAuthorized` will allow you to control allowed connections and allowed actions.\n\t *\n\t * However, if there is custom functionality you wish to include in the Interop Broker, please let us know. We would like to provide better configuration options so that you don't have to continually maintain your own override code.\n\t *\n\t * ```js\n\t * fin.Platform.init({\n\t *     overrideCallback: async (Provider) => {\n\t *         class Override extends Provider {\n\t *             async getSnapshot() {\n\t *                 console.log('before getSnapshot')\n\t *                 const snapshot = await super.getSnapshot();\n\t *                 console.log('after getSnapshot')\n\t *                 return snapshot;\n\t *             }\n\t *\n\t *             async applySnapshot({ snapshot, options }) {\n\t *                 console.log('before applySnapshot')\n\t *                 const originalPromise = super.applySnapshot({ snapshot, options });\n\t *                 console.log('after applySnapshot')\n\t *\n\t *                 return originalPromise;\n\t *             }\n\t *         };\n\t *         return new Override();\n\t *     },\n\t *     interopOverride: async (InteropBroker) => {\n\t *         class Override extends InteropBroker {\n\t *             async joinContextGroup(channelName = 'default', target) {\n\t *                 console.log('before super joinContextGroup')\n\t *                 super.joinContextGroup(channelName, target);\n\t *                 console.log('after super joinContextGroup')\n\t *             }\n\t *         }\n\t *\n\t *       return new Override();\n\t *   }\n\t * });\n\t * ```\n\t *\n\t * ---\n\t *\n\t */\n\tlet InteropBroker$1 = class InteropBroker extends base_1.Base {\n\t    /**\n\t     * @internal\n\t     */\n\t    constructor(wire, createProvider, options) {\n\t        // Tip from Pierre and Michael from the overrideCheck work: Don't use bound methods for overrideable InteropBroker functions.\n\t        super(wire);\n\t        _InteropBroker_fdc3Info.set(this, void 0);\n\t        _InteropBroker_contextGroups.set(this, void 0);\n\t        _InteropBroker_providerPromise.set(this, void 0);\n\t        this.getProvider = () => {\n\t            return __classPrivateFieldGet(this, _InteropBroker_providerPromise, \"f\").getValue();\n\t        };\n\t        this.interopClients = new Map();\n\t        this.contextGroupsById = new Map();\n\t        __classPrivateFieldSet(this, _InteropBroker_contextGroups, options.contextGroups ?? [...defaultContextGroups], \"f\");\n\t        __classPrivateFieldSet(this, _InteropBroker_fdc3Info, options.fdc3Info, \"f\");\n\t        if (options?.logging) {\n\t            this.logging = options.logging;\n\t        }\n\t        this.intentClientMap = new Map();\n\t        this.lastContextMap = new Map();\n\t        this.sessionContextGroupMap = new Map();\n\t        __classPrivateFieldSet(this, _InteropBroker_providerPromise, new lazy_1.Lazy(createProvider), \"f\");\n\t        this.setContextGroupMap();\n\t        this.setupChannelProvider();\n\t    }\n\t    static createClosedConstructor(...args) {\n\t        return class OverrideableBroker extends InteropBroker {\n\t            constructor(...unused) {\n\t                if (unused.length) {\n\t                    const [_ignore1, ignore2, opts] = unused;\n\t                    if (opts && typeof opts === 'object' && !(0, isEqual_1.default)(opts, args[2])) {\n\t                        // eslint-disable-next-line no-console\n\t                        console.warn('You have modified the parameters of the InteropOverride constructor. This behavior is deprecated and will be removed in a future version. You can modify these options in your manifest. Please consult our Interop docs for guidance on migrating to the new override scheme.');\n\t                        super(args[0], args[1], opts);\n\t                        return;\n\t                    }\n\t                    // eslint-disable-next-line no-console\n\t                    console.warn('You are attempting to pass arguments to the InteropOverride constructor. This is not necessary, and these passed arguments will be ignored. You are likely using an older InteropBroker override scheme. Please consult our Interop docs for guidance on migrating to the new override scheme.');\n\t                }\n\t                super(...args);\n\t            }\n\t        };\n\t    }\n\t    /*\n\t    Client API\n\t    */\n\t    /**\n\t     * Sets a context for the context group of the incoming current entity.\n\t     * @param setContextOptions - New context to set.\n\t     * @param clientIdentity - Identity of the client sender.\n\t     *\n\t     */\n\t    setContext({ context }, clientIdentity) {\n\t        this.wire.sendAction('interop-broker-set-context').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const clientState = this.getClientState(clientIdentity);\n\t        if (clientState && clientState.contextGroupId) {\n\t            const { contextGroupId } = clientState;\n\t            this.setContextForGroup({ context }, contextGroupId);\n\t        }\n\t        else if (clientState) {\n\t            // Client has not joined any context group behavior.\n\t            throw new Error('You must join a context group before you can set context.');\n\t        }\n\t        else {\n\t            // This shouldn't get hit.\n\t            throw new Error(`Client with Identity: ${clientIdentity.uuid} ${clientIdentity.name} not in Client State Map`);\n\t        }\n\t    }\n\t    /**\n\t     * Sets a context for the context group.\n\t     * @param setContextOptions - New context to set.\n\t     * @param contextGroupId - Context group id.\n\t     *\n\t     */\n\t    setContextForGroup({ context }, contextGroupId) {\n\t        this.wire.sendAction('interop-broker-set-context-for-group').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const contextGroupState = this.contextGroupsById.get(contextGroupId);\n\t        if (!contextGroupState) {\n\t            throw new Error(`Unable to set context for context group that isn't in the context group mapping: ${contextGroupId}.`);\n\t        }\n\t        const contextIntegrityCheckResult = InteropBroker.checkContextIntegrity(context);\n\t        if (contextIntegrityCheckResult.isValid === false) {\n\t            throw new Error(`Failed to set Context - bad Context. Reason: ${contextIntegrityCheckResult.reason}. Context: ${JSON.stringify(context)}`);\n\t        }\n\t        const broadcastedContextType = context.type;\n\t        contextGroupState.set(broadcastedContextType, context);\n\t        this.lastContextMap.set(contextGroupId, broadcastedContextType);\n\t        const clientsInSameContextGroup = Array.from(this.interopClients.values()).filter((connectedClient) => connectedClient.contextGroupId === contextGroupId);\n\t        clientsInSameContextGroup.forEach((client) => {\n\t            for (const [, handlerInfo] of client.contextHandlers) {\n\t                if (InteropBroker.isContextTypeCompatible(broadcastedContextType, handlerInfo.contextType)) {\n\t                    this.invokeContextHandler(client.clientIdentity, handlerInfo.handlerId, context);\n\t                }\n\t            }\n\t        });\n\t    }\n\t    /**\n\t     * Get current context for a client subscribed to a Context Group.\n\t     *\n\t     * @remarks It takes an optional Context Type argument and returns the last context of that type.\n\t     *\n\t     * @param getContextOptions - Options for getting context\n\t     * @param clientIdentity - Identity of the client sender.\n\t     *\n\t     */\n\t    getCurrentContext(getCurrentContextOptions, clientIdentity) {\n\t        this.wire.sendAction('interop-broker-get-current-context').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const clientState = this.getClientState(clientIdentity);\n\t        if (!clientState?.contextGroupId) {\n\t            throw new Error('You must be a member of a context group to call getCurrentContext');\n\t        }\n\t        const { contextGroupId } = clientState;\n\t        const contextGroupState = this.contextGroupsById.get(contextGroupId);\n\t        const lastContextType = this.lastContextMap.get(contextGroupId);\n\t        const contextType = getCurrentContextOptions?.contextType ?? lastContextType;\n\t        return contextGroupState && contextType ? contextGroupState.get(contextType) : undefined;\n\t    }\n\t    /*\n\t    Platform Window APIs\n\t    */\n\t    // joinContextGroup and addClientToContextGroup are separate functions here, for easier overrides and separation of concerns.\n\t    // joinContextGroup checks all connections for matching identities, in case we have multiple connection from an entity.\n\t    /**\n\t     * Join all connections at the given identity (or just one if endpointId provided) to context group `contextGroupId`.\n\t     * If no target is specified, it adds the sender to the context group.\n\t     * joinContextGroup is responsible for checking connections at the incoming identity. It calls {@link InteropBroker#addClientToContextGroup InteropBroker.addClientToContextGroup} to actually group the client.\n\t     * Used by Platform Windows.\n\t     *\n\t     * @param joinContextGroupOptions - Id of the Context Group and identity of the entity to join to the group.\n\t     * @param senderIdentity - Identity of the client sender.\n\t     */\n\t    async joinContextGroup({ contextGroupId, target }, senderIdentity) {\n\t        this.wire.sendAction('interop-broker-join-context-group').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        if (this.sessionContextGroupMap.has(contextGroupId)) {\n\t            throw new Error(utils_1.BROKER_ERRORS.joinSessionContextGroupWithJoinContextGroup);\n\t        }\n\t        if (target) {\n\t            // If an endpointId is provided, use that. This will likely be used by external adapters.\n\t            if (InteropBroker.hasEndpointId(target)) {\n\t                await this.addClientToContextGroup({ contextGroupId }, target);\n\t            }\n\t            // Sanity check here in case a single app has multiple connections\n\t            try {\n\t                const allConnections = this.channel.connections.filter((x) => x.uuid === target.uuid && x.name === target.name);\n\t                if (!allConnections.length) {\n\t                    throw new Error(`Given Identity ${target.uuid} ${target.name} is not connected to the Interop Broker.`);\n\t                }\n\t                if (allConnections.length > 1) {\n\t                    // Should figure out how we want to handle this situation. In the meantime, just change context group for all connections.\n\t                    console.warn(`More than one connection found for identity ${target.uuid} ${target.name}`);\n\t                }\n\t                const promises = [];\n\t                for (const connection of allConnections) {\n\t                    promises.push(this.addClientToContextGroup({ contextGroupId }, connection));\n\t                }\n\t                await Promise.all(promises);\n\t            }\n\t            catch (error) {\n\t                throw new Error(error);\n\t            }\n\t        }\n\t        else {\n\t            // No target provided, add the sender to the context group.\n\t            await this.addClientToContextGroup({ contextGroupId }, senderIdentity);\n\t        }\n\t    }\n\t    // addClientToContextGroup does the actual addition of the client to the Context Group\n\t    /**\n\t     * Helper function for {@link InteropBroker#joinContextGroup InteropBroker.joinContextGroup}. Does the work of actually adding the client to the Context Group.\n\t     * Used by Platform Windows.\n\t     *\n\t     * @param addClientToContextGroupOptions - Contains the contextGroupId\n\t     * @param clientIdentity - Identity of the client sender.\n\t     */\n\t    async addClientToContextGroup({ contextGroupId }, clientIdentity) {\n\t        this.wire.sendAction('interop-broker-add-client-to-context-group').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const clientSubscriptionState = this.getClientState(clientIdentity);\n\t        if (!clientSubscriptionState) {\n\t            throw new Error(`Client with Identity: ${clientIdentity.uuid} ${clientIdentity.name} not in Client State Map`);\n\t        }\n\t        if (!this.getContextGroups().find((contextGroupInfo) => contextGroupInfo.id === contextGroupId)) {\n\t            throw new Error(`Attempting to join a context group that does not exist: ${contextGroupId}. You may only join existing context groups.`);\n\t        }\n\t        const oldContextGroupId = clientSubscriptionState.contextGroupId;\n\t        if (oldContextGroupId !== contextGroupId) {\n\t            clientSubscriptionState.contextGroupId = contextGroupId;\n\t            await this.setCurrentContextGroupInClientOptions(clientIdentity, contextGroupId);\n\t            const contextGroupMap = this.contextGroupsById.get(contextGroupId);\n\t            for (const [, handlerInfo] of clientSubscriptionState.contextHandlers) {\n\t                const { contextType, handlerId } = handlerInfo;\n\t                if (contextType === undefined) {\n\t                    // Send this single handler all of the context, because it accepts all.\n\t                    contextGroupMap.forEach((context, _) => {\n\t                        this.invokeContextHandler(clientIdentity, handlerId, context);\n\t                    });\n\t                }\n\t                else if (contextGroupMap.has(contextType)) {\n\t                    const contextForType = contextGroupMap.get(contextType);\n\t                    if (contextForType) {\n\t                        this.invokeContextHandler(clientIdentity, handlerId, contextForType);\n\t                    }\n\t                }\n\t            }\n\t        }\n\t    }\n\t    // Removes the target from its context group. Similar structure to joinContextGroup.\n\t    /**\n\t     * Removes the specified target from a context group.\n\t     * If no target is specified, it removes the sender from their context group.\n\t     * removeFromContextGroup is responsible for checking connections at the incoming identity.\n\t     *\n\t     * @remarks It calls {@link InteropBroker#removeClientFromContextGroup InteropBroker.removeClientFromContextGroup} to actually ungroup\n\t     * the client. Used by Platform Windows.\n\t     *\n\t     * @param removeFromContextGroupOptions - Contains the target identity to remove.\n\t     * @param senderIdentity - Identity of the client sender.\n\t     */\n\t    async removeFromContextGroup({ target }, senderIdentity) {\n\t        this.wire.sendAction('interop-broker-remove-from-context-group').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        if (target) {\n\t            // If an endpointId is provided, use that. This will likely be used by external adapters.\n\t            if (InteropBroker.hasEndpointId(target)) {\n\t                await this.removeClientFromContextGroup(target);\n\t            }\n\t            try {\n\t                // Sanity check here in case a single app has multiple connections\n\t                const allConnections = this.channel.connections.filter((x) => x.uuid === target.uuid && x.name === target.name);\n\t                if (!allConnections.length) {\n\t                    throw new Error(`No connection found for given Identity ${target.uuid} ${target.name}`);\n\t                }\n\t                if (allConnections.length > 1) {\n\t                    console.warn(`More than one connection found for identity ${target.uuid} ${target.name}`);\n\t                }\n\t                const promises = [];\n\t                for (const connection of allConnections) {\n\t                    promises.push(this.removeClientFromContextGroup(connection));\n\t                }\n\t                await Promise.all(promises);\n\t            }\n\t            catch (error) {\n\t                throw new Error(error);\n\t            }\n\t        }\n\t        else {\n\t            // No target provided, remove the sender from the context group.\n\t            await this.removeClientFromContextGroup(senderIdentity);\n\t        }\n\t    }\n\t    // removeClientFromContextGroup does the actual remove of the client from the Context Group\n\t    /**\n\t     * Helper function for {@link InteropBroker#removeFromContextGroup InteropBroker.removeFromContextGroup}. Does the work of actually removing the client from the Context Group.\n\t     * Used by Platform Windows.\n\t     *\n\t     * @property { ClientIdentity } clientIdentity - Identity of the client sender.\n\t     */\n\t    async removeClientFromContextGroup(clientIdentity) {\n\t        this.wire.sendAction('interop-broker-remove-client-from-context-group').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const clientState = this.getClientState(clientIdentity);\n\t        if (clientState) {\n\t            clientState.contextGroupId = undefined;\n\t        }\n\t        await this.setCurrentContextGroupInClientOptions(clientIdentity, null);\n\t    }\n\t    // Used by platform windows to know what client groups the provider has declared. Also used internally to access context groups. Overrideable so that the platform developer can modify it.\n\t    /**\n\t     * Returns the Interop-Broker-defined context groups available for an entity to join. Because this function is used in the rest of the Interop Broker to fetch the Context Groups, overriding this allows you to customize the Context Groups for the Interop Broker. However, we recommend customizing the context groups through configuration instead.\n\t     * Used by Platform Windows.\n\t     *\n\t     */\n\t    // eslint-disable-next-line class-methods-use-this\n\t    getContextGroups() {\n\t        this.wire.sendAction('interop-broker-get-context-groups').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        // Create copy for immutability\n\t        return __classPrivateFieldGet(this, _InteropBroker_contextGroups, \"f\").map((contextGroup) => {\n\t            return { ...contextGroup };\n\t        });\n\t    }\n\t    // Used to by platform windows to get display metadata for a context group.\n\t    /**\n\t     * Gets display info for a context group\n\t     *\n\t     * @remarks Used by Platform Windows.\n\t     *\n\t     * @param getInfoForContextGroupOptions - Contains contextGroupId, the context group you wish to get display info for.\n\t     *\n\t     */\n\t    getInfoForContextGroup({ contextGroupId }) {\n\t        this.wire.sendAction('interop-broker-get-info-for-context-group').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        return this.getContextGroups().find((contextGroup) => contextGroup.id === contextGroupId);\n\t    }\n\t    // Used by platform windows to get all clients for a context group.\n\t    /**\n\t     * Gets all clients for a context group.\n\t     *\n\t     * @remarks **This is primarily used for platform windows. Views within a platform should not have to use this API.**\n\t     * Returns the Interop-Broker-defined context groups available for an entity to join.\n\t     *\n\t     * @param getAllClientsInContextGroupOptions - Contains contextGroupId, the context group you wish to get clients for.\n\t     *\n\t     */\n\t    getAllClientsInContextGroup({ contextGroupId }) {\n\t        this.wire.sendAction('interop-broker-get-all-clients-in-context-group').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const clientsInContextGroup = Array.from(this.interopClients.values())\n\t            .filter((connectedClient) => connectedClient.contextGroupId === contextGroupId)\n\t            .map((subscriptionState) => {\n\t            return subscriptionState.clientIdentity;\n\t        });\n\t        return clientsInContextGroup;\n\t    }\n\t    /**\n\t     * Responsible for launching of applications that can handle a given intent, and delegation of intents to those applications.\n\t     * Must be overridden.\n\t     *\n\t     * @remarks To make this call FDC3-Compliant it would need to return an IntentResolution.\n\t     *\n\t     * ```js\n\t     * interface IntentResolution {\n\t     *   source: TargetApp;\n\t     *   // deprecated, not assignable from intent listeners\n\t     *   data?: object;\n\t     *   version: string;\n\t     * }\n\t     * ```\n\t     *\n\t     * More information on the IntentResolution type can be found in the [FDC3 documentation](https://fdc3.finos.org/docs/api/ref/IntentResolution).\n\t     *\n\t     * @param intent The combination of an action and a context that is passed to an application for resolution.\n\t     * @param  clientIdentity Identity of the Client making the request.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * // override call so we set intent target and create view that will handle it\n\t     * fin.Platform.init({\n\t     *     interopOverride: async (InteropBroker) => {\n\t     *         class Override extends InteropBroker {\n\t     *             async handleFiredIntent(intent) {\n\t     *                 super.setIntentTarget(intent, { uuid: 'platform-uuid', name: 'intent-view' });\n\t     *                 const platform = fin.Platform.getCurrentSync();\n\t     *                 const win = fin.Window.wrapSync({ name: 'foo', uuid: 'platform-uuid' });\n\t     *                 const createdView = await platform.createView({ url: 'http://openfin.co', name: 'intent-view' }, win.identity);\n\t     *             }\n\t     *         }\n\t     *         return new Override();\n\t     *     }\n\t     * });\n\t     * ```\n\t     */\n\t    // eslint-disable-next-line class-methods-use-this\n\t    async handleFiredIntent(intent, clientIdentity // TODO(CORE-811): remove inline intersected type\n\t    ) {\n\t        const warning = (0, utils_1.generateOverrideWarning)('fdc3.raiseIntent', 'InteropBroker.handleFiredIntent', clientIdentity, 'interopClient.fireIntent');\n\t        console.warn(warning);\n\t        throw new Error(utils_1.BROKER_ERRORS.fireIntent);\n\t    }\n\t    /**\n\t     * Should be called in {@link InteropBroker#handleFiredIntent InteropBroker.handleFiredIntent}.\n\t     * While handleFiredIntent is responsible for launching applications, setIntentTarget is used to tell the InteropBroker which application should receive the intent when it is ready.\n\t     * @param intent The combination of an action and a context that is passed to an application for resolution.\n\t     * @param target - Identity of the target that will handle the intent.\n\t     *\n\t     */\n\t    async setIntentTarget(intent, target) {\n\t        this.wire.sendAction('interop-broker-set-intent-target').catch((e) => {\n\t            // don't expose, this is only for api analytics purposes\n\t        });\n\t        const targetInfo = this.intentClientMap.get(target.name);\n\t        const handlerId = `intent-handler-${intent.name}`;\n\t        if (!targetInfo) {\n\t            this.intentClientMap.set(target.name, new Map());\n\t            const newHandlerInfoMap = this.intentClientMap.get(target.name);\n\t            if (newHandlerInfoMap) {\n\t                newHandlerInfoMap.set(handlerId, { isReady: false, pendingIntents: [intent] });\n\t            }\n\t        }\n\t        else {\n\t            const handlerInfo = targetInfo.get(handlerId);\n\t            if (!handlerInfo) {\n\t                targetInfo.set(handlerId, { isReady: false, pendingIntents: [intent] });\n\t            }\n\t            else {\n\t                handlerInfo.pendingIntents.push(intent);\n\t                if (handlerInfo.clientIdentity && handlerInfo.isReady) {\n\t                    const { clientIdentity, pendingIntents } = handlerInfo;\n\t                    try {\n\t                        const intentToSend = pendingIntents[pendingIntents.length - 1];\n\t                        await this.invokeIntentHandler(clientIdentity, handlerId, intentToSend);\n\t                        handlerInfo.pendingIntents = [];\n\t                    }\n\t                    catch (error) {\n\t                        console.error(`Error invoking intent handler for client ${clientIdentity.uuid}/${clientIdentity.name}/${clientIdentity.endpointId}`);\n\t                        handlerInfo.isReady = false;\n\t                    }\n\t                }\n\t            }\n\t        }\n\t    }\n\t    /**\n\t     * Responsible for returning information on a particular Intent.\n\t     *\n\t     * @remarks Whenever InteropClient.getInfoForIntent is called this function will fire. The options argument gives you\n\t     * access to the intent name and any optional context that was passed and clientIdentity is the identity of the client\n\t     * that made the call. Ideally here you would fetch the info for the intent and return it with the shape that the\n\t     * InteropClient.getInfoForIntent call is expecting.\n\t     *\n\t     * To make this call FDC3-Compliant it would need to return an App Intent:\n\t     *\n\t     * ```js\n\t     * // {\n\t     * //     intent: { name: \"StartChat\", displayName: \"Chat\" },\n\t     * //     apps: [{ name: \"Skype\" }, { name: \"Symphony\" }, { name: \"Slack\" }]\n\t     * // }\n\t     * ```\n\t     *\n\t     * More information on the AppIntent type can be found in the [FDC3 documentation](https://fdc3.finos.org/docs/api/ref/AppIntent).\n\t     *\n\t     * @param options\n\t     * @param clientIdentity Identity of the Client making the request.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.Platform.init({\n\t     *     interopOverride: async (InteropBroker) => {\n\t     *         class Override extends InteropBroker {\n\t     *             async handleInfoForIntent(options, clientIdentity) {\n\t     *                 // Your code goes here.\n\t     *             }\n\t     *         }\n\t     *         return new Override();\n\t     *     }\n\t     * });\n\t     * ```\n\t     */\n\t    // eslint-disable-next-line class-methods-use-this\n\t    async handleInfoForIntent(options, clientIdentity // TODO(CORE-811): remove inline intersected type\n\t    ) {\n\t        const warning = (0, utils_1.generateOverrideWarning)('fdc3.findIntent', 'InteropBroker.handleInfoForIntent', clientIdentity, 'interopClient.getInfoForIntent');\n\t        console.warn(warning);\n\t        throw new Error(utils_1.BROKER_ERRORS.getInfoForIntent);\n\t    }\n\t    /**\n\t     * Responsible for returning information on which Intents are meant to handle a specific Context.\n\t     * Must be overridden.\n\t     *\n\t     * @remarks Responsible for returning information on which Intents are meant to handle a specific Context. Must be overridden.\n\t     *\n\t     * Whenever InteropClient.getInfoForIntentsByContext is called this function will fire. The context argument gives you access to the context that the client wants information on and clientIdentity is the identity of the client that made the call. Ideally here you would fetch the info for any intent that can handle and return it with the shape that the InteropClient.getInfoForIntentsByContext call is expecting.\n\t     *\n\t     * To make this call FDC3-Compliant it would need to return an array of AppIntents:\n\t     *\n\t     * ```js\n\t     * // [{\n\t     * //     intent: { name: \"StartCall\", displayName: \"Call\" },\n\t     * //     apps: [{ name: \"Skype\" }]\n\t     * // },\n\t     * // {\n\t     * //     intent: { name: \"StartChat\", displayName: \"Chat\" },\n\t     * //     apps: [{ name: \"Skype\" }, { name: \"Symphony\" }, { name: \"Slack\" }]\n\t     * // }];\n\t     * ```\n\t     *\n\t     * More information on the AppIntent type can be found in the [FDC3 documentation](https://fdc3.finos.org/docs/api/ref/AppIntent).\n\t     *\n\t     * @param context Data passed between entities and applications.\n\t     * @param clientIdentity Identity of the Client making the request.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.Platform.init({\n\t     *     interopOverride: async (InteropBroker) => {\n\t     *         class Override extends InteropBroker {\n\t     *             async handleInfoForIntentsByContext(context, clientIdentity) {\n\t     *                 // Your code goes here.\n\t     *             }\n\t     *         }\n\t     *         return new Override();\n\t     *     }\n\t     * });\n\t     * ```\n\t     */\n\t    // eslint-disable-next-line class-methods-use-this\n\t    async handleInfoForIntentsByContext(context, clientIdentity // TODO(CORE-811): remove inline intersected type\n\t    ) {\n\t        const warning = (0, utils_1.generateOverrideWarning)('fdc3.findIntentsByContext', 'InteropBroker.handleInfoForIntentsByContext', clientIdentity, 'interopClient.getInfoForIntentsByContext');\n\t        console.warn(warning);\n\t        throw new Error(utils_1.BROKER_ERRORS.getInfoForIntentsByContext);\n\t    }\n\t    /**\n\t     * Responsible for resolving an Intent based on a specific Context.\n\t     * Must be overridden.\n\t     *\n\t     * @remarks Whenever InteropClient.fireIntentForContext is called this function will fire. The contextForIntent argument\n\t     * gives you access to the context that will be resolved to an intent. It also can optionally contain any metadata relevant\n\t     * to resolving it, like a specific app the client wants the context to be handled by. The clientIdentity is the identity\n\t     * of the client that made the call.\n\t     *\n\t     * To make this call FDC3-Compliant it would need to return an IntentResolution:\n\t     *\n\t     * ```js\n\t     * // {\n\t     * //     intent: { name: \"StartChat\", displayName: \"Chat\" },\n\t     * //     apps: [{ name: \"Skype\" }, { name: \"Symphony\" }, { name: \"Slack\" }]\n\t     * // }\n\t     * ```\n\t     *\n\t     * More information on the IntentResolution type can be found in the [FDC3 documentation](https://fdc3.finos.org/docs/api/ref/Metadata#intentresolution).\n\t     *\n\t     * @param contextForIntent Data passed between entities and applications.\n\t     * @param clientIdentity Identity of the Client making the request.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.Platform.init({\n\t     *     interopOverride: async (InteropBroker) => {\n\t     *         class Override extends InteropBroker {\n\t     *             async handleFiredIntentForContext(contextForIntent, clientIdentity) {\n\t     *                 // Your code goes here.\n\t     *             }\n\t     *         }\n\t     *         return new Override();\n\t     *     }\n\t     * });\n\t     * ```\n\t     */\n\t    // eslint-disable-next-line class-methods-use-this\n\t    async handleFiredIntentForContext(contextForIntent, clientIdentity) {\n\t        const warning = (0, utils_1.generateOverrideWarning)('fdc3.raiseIntentForContext', 'InteropBroker.handleFiredIntentForContext', clientIdentity, 'interopClient.fireIntentForContext');\n\t        console.warn(warning);\n\t        throw new Error(utils_1.BROKER_ERRORS.fireIntentForContext);\n\t    }\n\t    /**\n\t     * Provides the identity of any Interop Client that disconnects from the Interop Broker. It is meant to be overriden.\n\t     * @param clientIdentity\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.Platform.init({\n\t     *     interopOverride: async (InteropBroker) => {\n\t     *         class Override extends InteropBroker {\n\t     *             async clientDisconnected(clientIdentity) {\n\t     *                 const { uuid, name } = clientIdentity;\n\t     *                 console.log(`Client with identity ${uuid}/${name} has been disconnected`);\n\t     *             }\n\t     *         }\n\t     *         return new Override();\n\t     *     }\n\t     * });\n\t     * ```\n\t     */\n\t    // eslint-disable-next-line class-methods-use-this\n\t    async clientDisconnected(clientIdentity) {\n\t        // This function is called in channel.onDisconnection.\n\t        // It is meant to be overridden to inform when an Interop Client has been disconnected.\n\t    }\n\t    /**\n\t     * Responsible for resolving an fdc3.open call.\n\t     * Must be overridden.\n\t     * @param fdc3OpenOptions fdc3.open options\n\t     * @param clientIdentity Identity of the Client making the request.\n\t     */\n\t    // eslint-disable-next-line class-methods-use-this\n\t    async fdc3HandleOpen({ app, context }, clientIdentity) {\n\t        const warning = (0, utils_1.generateOverrideWarning)('fdc3.open', 'InteropBroker.fdc3HandleOpen', clientIdentity);\n\t        console.warn(warning);\n\t        throw new Error(utils_1.BROKER_ERRORS.fdc3Open);\n\t    }\n\t    /**\n\t     * Responsible for resolving the fdc3.findInstances call.\n\t     * Must be overridden\n\t     * @param app AppIdentifier that was passed to fdc3.findInstances\n\t     * @param clientIdentity Identity of the Client making the request.\n\t     */\n\t    // eslint-disable-next-line class-methods-use-this\n\t    async fdc3HandleFindInstances(app, clientIdentity) {\n\t        const warning = (0, utils_1.generateOverrideWarning)('fdc3.open', 'InteropBroker.fdc3HandleFindInstances', clientIdentity);\n\t        console.warn(warning);\n\t        throw new Error(utils_1.BROKER_ERRORS.fdc3FindInstances);\n\t    }\n\t    /**\n\t     * Responsible for resolving the fdc3.getAppMetadata call.\n\t     * Must be overridden\n\t     * @param app AppIdentifier that was passed to fdc3.getAppMetadata\n\t     * @param clientIdentity Identity of the Client making the request.\n\t     */\n\t    // eslint-disable-next-line class-methods-use-this\n\t    async fdc3HandleGetAppMetadata(app, clientIdentity) {\n\t        const warning = (0, utils_1.generateOverrideWarning)('fdc3.getAppMetadata', 'InteropBroker.fdc3HandleGetAppMetadata', clientIdentity);\n\t        console.warn(warning);\n\t        throw new Error(utils_1.BROKER_ERRORS.fdc3GetAppMetadata);\n\t    }\n\t    /**\n\t     * This function is called by the Interop Broker whenever a Context handler would fire.\n\t     * For FDC3 2.0 you would need to override this function and add the contextMetadata as\n\t     * part of the Context object. Then would you need to call\n\t     * super.invokeContextHandler passing it this new Context object along with the clientIdentity and handlerId\n\t     * @param clientIdentity\n\t     * @param handlerId\n\t     * @param context\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.Platform.init({\n\t     *     interopOverride: async (InteropBroker) => {\n\t     *         class Override extends InteropBroker {\n\t     *             async invokeContextHandler(clientIdentity, handlerId, context) {\n\t     *                 return super.invokeContextHandler(clientIdentity, handlerId, {\n\t     *                     ...context,\n\t     *                     contextMetadata: {\n\t     *                         source: {\n\t     *                             appId: 'openfin-app',\n\t     *                             instanceId: '3D54D456D9HT0'\n\t     *                         }\n\t     *                     }\n\t     *                 });\n\t     *             }\n\t     *         }\n\t     *         return new Override();\n\t     *     }\n\t     * });\n\t     * ```\n\t     */\n\t    async invokeContextHandler(clientIdentity, handlerId, context) {\n\t        const provider = await this.getProvider();\n\t        try {\n\t            await provider.dispatch(clientIdentity, handlerId, context);\n\t        }\n\t        catch (error) {\n\t            console.error(`Error invoking context handler ${handlerId} for context type ${context.type} in client ${clientIdentity.uuid}/${clientIdentity.name}/${clientIdentity.endpointId}`, error);\n\t        }\n\t    }\n\t    /**\n\t     * This function is called by the Interop Broker whenever an Intent handler would fire.\n\t     * For FDC3 2.0 you would need to override this function and add the contextMetadata as\n\t     * part of the Context object inside the Intent object. Then would you need to call\n\t     * super.invokeIntentHandler passing it this new Intent object along with the clientIdentity and handlerId\n\t     * @param ClientIdentity\n\t     * @param handlerId\n\t     * @param context\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.Platform.init({\n\t     *     interopOverride: async (InteropBroker) => {\n\t     *         class Override extends InteropBroker {\n\t     *             async invokeIntentHandler(clientIdentity, handlerId, context) {\n\t     *                 const { context } = intent;\n\t     *                 return super.invokeIntentHandler(clientIdentity, handlerId, {\n\t     *                     ...intent,\n\t     *                     context: {\n\t     *                         ...context,\n\t     *                         contextMetadata: {\n\t     *                             source: {\n\t     *                                 appId: 'openfin-app',\n\t     *                                 instanceId: '3D54D456D9HT0'\n\t     *                             }\n\t     *                         }\n\t     *                     }\n\t     *                 });\n\t     *             }\n\t     *         }\n\t     *         return new Override();\n\t     *     }\n\t     * });\n\t     * ```\n\t     */\n\t    async invokeIntentHandler(clientIdentity, handlerId, intent) {\n\t        const provider = await this.getProvider();\n\t        await provider.dispatch(clientIdentity, handlerId, intent);\n\t    }\n\t    /**\n\t     * Responsible for resolving fdc3.getInfo for FDC3 2.0\n\t     * Would need to return the optionalFeatures and appMetadata for the {@link https://fdc3.finos.org/docs/api/ref/Metadata#implementationmetadata ImplementationMetadata}.\n\t     * Must be overridden.\n\t     * @param clientIdentity\n\t     *\n\t     */\n\t    // eslint-disable-next-line class-methods-use-this\n\t    async fdc3HandleGetInfo(payload, clientIdentity) {\n\t        const { fdc3Version } = payload;\n\t        return {\n\t            fdc3Version,\n\t            ...__classPrivateFieldGet(this, _InteropBroker_fdc3Info, \"f\"),\n\t            optionalFeatures: {\n\t                OriginatingAppMetadata: false,\n\t                UserChannelMembershipAPIs: true\n\t            },\n\t            appMetadata: {\n\t                appId: '',\n\t                instanceId: ''\n\t            }\n\t        };\n\t    }\n\t    /**\n\t     * Returns an array of info for each Interop Client connected to the Interop Broker.\n\t     *\n\t     * FDC3 2.0: Use the endpointId in the ClientInfo as the instanceId when generating\n\t     * an AppIdentifier.\n\t     *\n\t     * @remarks FDC3 2.0 Note: When needing an instanceId to generate an AppIdentifier use this call to\n\t     * get the endpointId and use it as the instanceId. In the Example below we override handleFiredIntent\n\t     * and then call super.getAllClientInfo to generate the AppIdentifier for the IntentResolution.\n\t     *\n\t     *\n\t     * @example\n\t     * ```js\n\t     * // FDC3 2.0 Example:\n\t     * fin.Platform.init({\n\t     *     interopOverride: async (InteropBroker, ...args) => {\n\t     *         class Override extends InteropBroker {\n\t     *             async handleFiredIntent(intent) {\n\t     *                 super.setIntentTarget(intent, { uuid: 'platform-uuid', name: 'intent-view' });\n\t     *                 const platform = fin.Platform.getCurrentSync();\n\t     *                 const win = fin.Window.wrapSync({ name: 'foo', uuid: 'platform-uuid' });\n\t     *                 const createdView = await platform.createView({ url: 'http://openfin.co', name: 'intent-view' }, win.identity);\n\t     *\n\t     *                 const allClientInfo = await super.getAllClientInfo();\n\t     *\n\t     *                 const infoForTarget = allClientInfo.find((clientInfo) => {\n\t     *                     return clientInfo.uuid === 'platform-uuid' && clientInfo.name === 'intent-view';\n\t     *                 });\n\t     *\n\t     *                 const source = {\n\t     *                     appId: 'intent-view',\n\t     *                     instanceId: infoForTarget.endpointId\n\t     *                 }\n\t     *\n\t     *                 return {\n\t     *                     source,\n\t     *                     intent: intent.name\n\t     *                 }\n\t     *\n\t     *             }\n\t     *         }\n\t     *         return new Override(...args);\n\t     *     }\n\t     * });\n\t     * ```\n\t     */\n\t    async getAllClientInfo() {\n\t        const provider = await this.getProvider();\n\t        return provider.getAllClientInfo();\n\t    }\n\t    /*\n\t    Snapshot APIs\n\t    */\n\t    // Used to save interop broker state in snapshots\n\t    decorateSnapshot(snapshot) {\n\t        return { ...snapshot, interopSnapshotDetails: { contextGroupStates: this.getContextGroupStates() } };\n\t    }\n\t    // Used to restore interop broker state in snapshots.\n\t    applySnapshot(snapshot, options) {\n\t        const contextGroupStates = snapshot?.interopSnapshotDetails?.contextGroupStates;\n\t        if (contextGroupStates) {\n\t            if (!options?.closeExistingWindows) {\n\t                this.updateExistingClients(contextGroupStates);\n\t            }\n\t            this.rehydrateContextGroupStates(contextGroupStates);\n\t        }\n\t    }\n\t    updateExistingClients(contextGroupStates) {\n\t        const clients = this.interopClients;\n\t        clients.forEach((subState) => {\n\t            const { clientIdentity, contextGroupId, contextHandlers } = subState;\n\t            if (contextGroupId) {\n\t                const groupContexts = contextGroupStates[contextGroupId];\n\t                for (const [, context] of Object.entries(groupContexts)) {\n\t                    contextHandlers.forEach((contextHandler) => {\n\t                        const { handlerId, contextType } = contextHandler;\n\t                        if (InteropBroker.isContextTypeCompatible(context.type, contextType)) {\n\t                            this.invokeContextHandler(clientIdentity, handlerId, context);\n\t                        }\n\t                    });\n\t                }\n\t            }\n\t        });\n\t    }\n\t    // Used to store context group state in snapshots\n\t    getContextGroupStates() {\n\t        return InteropBroker.toObject(this.contextGroupsById);\n\t    }\n\t    // Used to rehydrate the context state from a snapshot\n\t    rehydrateContextGroupStates(incomingContextGroupStates) {\n\t        const contextGroupStates = Object.entries(incomingContextGroupStates);\n\t        for (const [contextGroupId, contexts] of contextGroupStates) {\n\t            const contextObjects = Object.entries(contexts);\n\t            for (const [contextType, context] of contextObjects) {\n\t                if (this.contextGroupsById.has(contextGroupId)) {\n\t                    const currentContextGroupState = this.contextGroupsById.get(contextGroupId);\n\t                    currentContextGroupState.set(contextType, context);\n\t                }\n\t                else {\n\t                    // This logic will change when dynamic context group creation comes in.\n\t                    console.warn(`Attempting to set a context group that isn't in the context group mapping. Skipping context group rehydration for: ${contextGroupId}`);\n\t                }\n\t            }\n\t        }\n\t    }\n\t    /*\n\t    Internal Context Handler APIs\n\t    */\n\t    // Used to give context to a client that has registered their context handler\n\t    contextHandlerRegistered({ contextType, handlerId }, clientIdentity) {\n\t        const handlerInfo = { contextType, handlerId };\n\t        const clientState = this.getClientState(clientIdentity);\n\t        clientState?.contextHandlers.set(handlerId, handlerInfo);\n\t        if (clientState && clientState.contextGroupId) {\n\t            const { contextGroupId } = clientState;\n\t            const contextGroupMap = this.contextGroupsById.get(contextGroupId);\n\t            if (contextType === undefined) {\n\t                // Send this single handler all of the context, because it accepts all.\n\t                contextGroupMap.forEach((context, _) => {\n\t                    this.invokeContextHandler(clientIdentity, handlerId, context);\n\t                });\n\t            }\n\t            else if (contextGroupMap.has(contextType)) {\n\t                const contextForType = contextGroupMap.get(contextType);\n\t                if (contextForType) {\n\t                    this.invokeContextHandler(clientIdentity, handlerId, contextForType);\n\t                }\n\t            }\n\t        }\n\t    }\n\t    // eslint-disable-next-line class-methods-use-this\n\t    async intentHandlerRegistered(payload, clientIdentity) {\n\t        const { handlerId } = payload;\n\t        const clientIntentInfo = this.intentClientMap.get(clientIdentity.name);\n\t        const handlerInfo = clientIntentInfo?.get(handlerId);\n\t        if (!clientIntentInfo) {\n\t            this.intentClientMap.set(clientIdentity.name, new Map());\n\t            const newHandlerInfoMap = this.intentClientMap.get(clientIdentity.name);\n\t            if (newHandlerInfoMap) {\n\t                newHandlerInfoMap.set(handlerId, { isReady: true, pendingIntents: [], clientIdentity });\n\t            }\n\t        }\n\t        else if (!handlerInfo) {\n\t            clientIntentInfo.set(handlerId, { isReady: true, pendingIntents: [], clientIdentity });\n\t        }\n\t        else {\n\t            const { pendingIntents } = handlerInfo;\n\t            handlerInfo.clientIdentity = clientIdentity;\n\t            handlerInfo.isReady = true;\n\t            try {\n\t                if (pendingIntents.length > 0) {\n\t                    const intentToSend = pendingIntents[pendingIntents.length - 1];\n\t                    await this.invokeIntentHandler(clientIdentity, handlerId, intentToSend);\n\t                    handlerInfo.pendingIntents = [];\n\t                }\n\t            }\n\t            catch (error) {\n\t                console.error(`Error invoking intent handler: ${handlerId} for client ${clientIdentity.uuid}/${clientIdentity.name}/${clientIdentity.endpointId}`);\n\t            }\n\t        }\n\t    }\n\t    // Used to remove a context handler for a client\n\t    removeContextHandler({ handlerId }, clientIdentity) {\n\t        const clientState = this.getClientState(clientIdentity);\n\t        if (clientState) {\n\t            clientState.contextHandlers.delete(handlerId);\n\t        }\n\t    }\n\t    handleJoinSessionContextGroup({ sessionContextGroupId }, clientIdentity) {\n\t        try {\n\t            if (!sessionContextGroupId) {\n\t                throw new Error('Failed to join session context group: must specify group id.');\n\t            }\n\t            const sessionContextGroup = this.sessionContextGroupMap.get(sessionContextGroupId);\n\t            if (sessionContextGroup) {\n\t                sessionContextGroup.registerNewClient(clientIdentity);\n\t            }\n\t            else {\n\t                const newSessionContextGroupBroker = new SessionContextGroupBroker_1.default(this.channel, sessionContextGroupId);\n\t                newSessionContextGroupBroker.registerNewClient(clientIdentity);\n\t                this.sessionContextGroupMap.set(sessionContextGroupId, newSessionContextGroupBroker);\n\t            }\n\t            return { hasConflict: this.contextGroupsById.has(sessionContextGroupId) };\n\t        }\n\t        catch (error) {\n\t            throw new Error(error);\n\t        }\n\t    }\n\t    /*\n\t    Internal Utilties\n\t    */\n\t    // Getter for interop info for a client.\n\t    getClientState(id) {\n\t        return this.interopClients.get(id.endpointId);\n\t    }\n\t    // Util for getContextGroupStates. Serializes the contextGroupStates object so we can store it.\n\t    static toObject(map) {\n\t        const objectFromMap = Object.fromEntries(map);\n\t        const newObject = {};\n\t        Object.entries(objectFromMap).forEach(([contextGroupId, contextMap]) => {\n\t            const newContextObject = Object.fromEntries(contextMap);\n\t            newObject[contextGroupId] = newContextObject;\n\t        });\n\t        return newObject;\n\t    }\n\t    static checkContextIntegrity(context) {\n\t        if (!context) {\n\t            return { isValid: false, reason: 'No context supplied' };\n\t        }\n\t        if (typeof context !== 'object') {\n\t            return { isValid: false, reason: 'Context must be an Object' };\n\t        }\n\t        if (!context.type) {\n\t            return { isValid: false, reason: 'Context must have a type property' };\n\t        }\n\t        if (context.id && typeof context.id !== 'object') {\n\t            return {\n\t                isValid: false,\n\t                reason: 'Context id must be an Object populated with key-value identifiers (if set)'\n\t            };\n\t        }\n\t        if (context.id) {\n\t            const { id } = context;\n\t            const keys = Object.keys(id);\n\t            let foundBadIdentifier = false;\n\t            if (!keys.length) {\n\t                return { isValid: false, reason: 'Context id must have at least one key-value identifier' };\n\t            }\n\t            keys.forEach((key) => {\n\t                if (typeof key !== 'string' || typeof id[key] !== 'string') {\n\t                    foundBadIdentifier = true;\n\t                }\n\t            });\n\t            if (foundBadIdentifier) {\n\t                return { isValid: false, reason: 'Context id key-value identifiers must be of type string' };\n\t            }\n\t        }\n\t        if (context.name && typeof context.name !== 'string') {\n\t            return { isValid: false, reason: 'Context name must be of string type (if set)' };\n\t        }\n\t        return { isValid: true };\n\t    }\n\t    // Util to check a client identity.\n\t    static hasEndpointId(target) {\n\t        return target.endpointId !== undefined;\n\t    }\n\t    // Util to check if we should send a context to a handler.\n\t    static isContextTypeCompatible(contextType, registeredContextType) {\n\t        return typeof registeredContextType === 'undefined' || contextType === registeredContextType;\n\t    }\n\t    // Setup function for state mapping\n\t    setContextGroupMap() {\n\t        // This way, if a user overrides this.getContextGroups, it's reflected in the contextGroupMapping.\n\t        for (const contextGroupInfo of this.getContextGroups()) {\n\t            this.contextGroupsById.set(contextGroupInfo.id, new Map());\n\t        }\n\t    }\n\t    async setCurrentContextGroupInClientOptions(clientIdentity, contextGroupId) {\n\t        try {\n\t            const entityInfo = await this.fin.System.getEntityInfo(clientIdentity.uuid, clientIdentity.name);\n\t            let entity;\n\t            if (entityInfo.entityType === 'view') {\n\t                entity = await this.fin.View.wrap(clientIdentity);\n\t            }\n\t            else if (entityInfo.entityType === 'window') {\n\t                entity = await this.fin.Window.wrap(clientIdentity);\n\t            }\n\t            if (entity) {\n\t                await entity.updateOptions({\n\t                    interop: {\n\t                        currentContextGroup: contextGroupId\n\t                    }\n\t                });\n\t            }\n\t        }\n\t        catch (error) {\n\t            //  May file in interop\n\t        }\n\t    }\n\t    async setupChannelProvider() {\n\t        try {\n\t            const channel = await this.getProvider();\n\t            this.channel = channel;\n\t            this.wireChannel(channel);\n\t        }\n\t        catch (error) {\n\t            throw new Error(`Error setting up Interop Broker Channel Provider: ${error}`);\n\t        }\n\t    }\n\t    // Setup Channel Connection Logic\n\t    wireChannel(channel) {\n\t        channel.onConnection(async (clientIdentity, // TODO(CORE-811): remove inline intersected type\n\t        payload) => {\n\t            if (!(await this.isConnectionAuthorized(clientIdentity, payload))) {\n\t                throw new Error(`Connection not authorized for ${clientIdentity.uuid}, ${clientIdentity.name}`);\n\t            }\n\t            if (!clientIdentity.endpointId) {\n\t                throw new Error('Version too old to be compatible with Interop. Please upgrade your runtime to a more recent version.');\n\t            }\n\t            const clientSubscriptionState = {\n\t                contextGroupId: undefined,\n\t                contextHandlers: new Map(),\n\t                clientIdentity\n\t            };\n\t            // Only allow the client to join a contextGroup that actually exists.\n\t            if (payload?.currentContextGroup && this.contextGroupsById.has(payload.currentContextGroup)) {\n\t                clientSubscriptionState.contextGroupId = payload?.currentContextGroup;\n\t            }\n\t            this.interopClients.set(clientIdentity.endpointId, clientSubscriptionState);\n\t        });\n\t        channel.onDisconnection((clientIdentity) => {\n\t            this.interopClients.delete(clientIdentity.endpointId);\n\t            const targetInfo = this.intentClientMap.get(clientIdentity.name);\n\t            if (targetInfo && clientIdentity.uuid === this.fin.me.uuid) {\n\t                targetInfo.forEach((handler) => {\n\t                    handler.isReady = false;\n\t                });\n\t            }\n\t            this.sessionContextGroupMap.forEach((sessionContextGroup) => {\n\t                sessionContextGroup.onDisconnection(clientIdentity);\n\t            });\n\t            this.clientDisconnected(clientIdentity);\n\t        });\n\t        channel.beforeAction(async (action, payload, clientIdentity) => {\n\t            if (!(await this.isActionAuthorized(action, payload, clientIdentity))) {\n\t                throw new Error(`Action (${action}) not authorized for ${clientIdentity.uuid}, ${clientIdentity.name}`);\n\t            }\n\t            if (this.logging?.beforeAction?.enabled) {\n\t                console.log(action, payload, clientIdentity);\n\t            }\n\t        });\n\t        channel.afterAction((action, payload, clientIdentity) => {\n\t            if (this.logging?.afterAction?.enabled) {\n\t                console.log(action, payload, clientIdentity);\n\t            }\n\t        });\n\t        // Client functions\n\t        channel.register('setContext', this.setContext.bind(this));\n\t        channel.register('fireIntent', this.handleFiredIntent.bind(this));\n\t        channel.register('getCurrentContext', this.getCurrentContext.bind(this));\n\t        channel.register('getInfoForIntent', this.handleInfoForIntent.bind(this));\n\t        channel.register('getInfoForIntentsByContext', this.handleInfoForIntentsByContext.bind(this));\n\t        channel.register('fireIntentForContext', this.handleFiredIntentForContext.bind(this));\n\t        // Platform window functions\n\t        channel.register('getContextGroups', this.getContextGroups.bind(this));\n\t        channel.register('joinContextGroup', this.joinContextGroup.bind(this));\n\t        channel.register('removeFromContextGroup', this.removeFromContextGroup.bind(this));\n\t        channel.register('getAllClientsInContextGroup', this.getAllClientsInContextGroup.bind(this));\n\t        channel.register('getInfoForContextGroup', this.getInfoForContextGroup.bind(this));\n\t        // Internal methods\n\t        channel.register('contextHandlerRegistered', this.contextHandlerRegistered.bind(this));\n\t        channel.register('intentHandlerRegistered', this.intentHandlerRegistered.bind(this));\n\t        channel.register('removeContextHandler', this.removeContextHandler.bind(this));\n\t        channel.register('sessionContextGroup:createIfNeeded', this.handleJoinSessionContextGroup.bind(this));\n\t        // fdc3 only methods\n\t        channel.register('fdc3Open', this.fdc3HandleOpen.bind(this));\n\t        channel.register('fdc3v2FindIntentsByContext', this.handleInfoForIntentsByContext.bind(this));\n\t        channel.register('fdc3FindInstances', this.fdc3HandleFindInstances.bind(this));\n\t        channel.register('fdc3GetAppMetadata', this.fdc3HandleGetAppMetadata.bind(this));\n\t        channel.register('fdc3v2GetInfo', async (payload, clientIdentity) => {\n\t            return this.fdc3HandleGetInfo.bind(this)(payload, clientIdentity);\n\t        });\n\t        channel.register('createPrivateChannelProvider', async (payload) => {\n\t            const { channelId } = payload;\n\t            const channelProvider = await this.fin.InterApplicationBus.Channel.create(channelId);\n\t            PrivateChannelProvider_1.PrivateChannelProvider.init(channelProvider, channelId);\n\t        });\n\t    }\n\t    /**\n\t     * Can be used to completely prevent a connection. Return false to prevent connections. Allows all connections by default.\n\t     * @param _id the identity tryinc to connect\n\t     * @param _connectionPayload optional payload to use in custom implementations, will be undefined by default\n\t     */\n\t    isConnectionAuthorized(_id, _connectionPayload) {\n\t        this.wire.sendAction('interop-broker-is-connection-authorized').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        return Promise.resolve(true);\n\t    }\n\t    /**\n\t     * Called before every action to check if this entity should be allowed to take the action.\n\t     * Return false to prevent the action\n\t     * @param _action the string action to authorize in camel case\n\t     * @param _payload the data being sent for this action\n\t     * @param _identity the connection attempting to dispatch this action\n\t     */\n\t    isActionAuthorized(_action, _payload, _identity) {\n\t        this.wire.sendAction('interop-broker-is-action-authorized').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        return Promise.resolve(true);\n\t    }\n\t};\n\tInteropBroker.InteropBroker = InteropBroker$1;\n\t_InteropBroker_fdc3Info = new WeakMap(), _InteropBroker_contextGroups = new WeakMap(), _InteropBroker_providerPromise = new WeakMap();\n\treturn InteropBroker;\n}\n\nvar InteropClient = {};\n\nvar SessionContextGroupClient$1 = {};\n\nvar __classPrivateFieldSet$2 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar __classPrivateFieldGet$2 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar _SessionContextGroupClient_clientPromise;\nObject.defineProperty(SessionContextGroupClient$1, \"__esModule\", { value: true });\nconst base_1$2 = base;\nconst utils_1$2 = utils$3;\nclass SessionContextGroupClient extends base_1$2.Base {\n    constructor(wire, client, id) {\n        super(wire);\n        _SessionContextGroupClient_clientPromise.set(this, void 0);\n        this.id = id;\n        __classPrivateFieldSet$2(this, _SessionContextGroupClient_clientPromise, client, \"f\");\n    }\n    /**\n     * Sets a context for the session context group.\n     * @param context - New context to set.\n     *\n     * @tutorial interop.setContext\n     */\n    async setContext(context) {\n        this.wire.sendAction('interop-session-context-group-set-context').catch((e) => {\n            // don't expose, analytics-only call\n        });\n        const client = await __classPrivateFieldGet$2(this, _SessionContextGroupClient_clientPromise, \"f\");\n        return client.dispatch(`sessionContextGroup:setContext-${this.id}`, {\n            sessionContextGroupId: this.id,\n            context\n        });\n    }\n    async getCurrentContext(type) {\n        this.wire.sendAction('interop-session-context-group-get-context').catch((e) => {\n            // don't expose, analytics-only call\n        });\n        const client = await __classPrivateFieldGet$2(this, _SessionContextGroupClient_clientPromise, \"f\");\n        return client.dispatch(`sessionContextGroup:getContext-${this.id}`, {\n            sessionContextGroupId: this.id,\n            type\n        });\n    }\n    async addContextHandler(contextHandler, contextType) {\n        this.wire.sendAction('interop-session-context-group-add-handler').catch((e) => {\n            // don't expose, analytics-only call\n        });\n        if (typeof contextHandler !== 'function') {\n            throw new Error(\"Non-function argument passed to the first parameter 'handler'. Be aware that the argument order does not match the FDC3 standard.\");\n        }\n        const client = await __classPrivateFieldGet$2(this, _SessionContextGroupClient_clientPromise, \"f\");\n        let handlerId;\n        if (contextType) {\n            handlerId = `sessionContextHandler:invoke-${this.id}-${contextType}-${(0, utils_1$2.generateId)()}`;\n        }\n        else {\n            handlerId = `sessionContextHandler:invoke-${this.id}`;\n        }\n        client.register(handlerId, (0, utils_1$2.wrapContextHandler)(contextHandler, handlerId));\n        await client.dispatch(`sessionContextGroup:handlerAdded-${this.id}`, { handlerId, contextType });\n        return { unsubscribe: await this.createUnsubscribeCb(handlerId) };\n    }\n    async createUnsubscribeCb(handlerId) {\n        const client = await __classPrivateFieldGet$2(this, _SessionContextGroupClient_clientPromise, \"f\");\n        return async () => {\n            client.remove(handlerId);\n            await client.dispatch(`sessionContextGroup:handlerRemoved-${this.id}`, { handlerId });\n        };\n    }\n    getUserInstance() {\n        return {\n            id: this.id,\n            setContext: (0, utils_1$2.wrapInTryCatch)(this.setContext.bind(this), 'Failed to set context: '),\n            getCurrentContext: (0, utils_1$2.wrapInTryCatch)(this.getCurrentContext.bind(this), 'Failed to get context: '),\n            addContextHandler: (0, utils_1$2.wrapInTryCatch)(this.addContextHandler.bind(this), 'Failed to add context handler: ')\n        };\n    }\n}\nSessionContextGroupClient$1.default = SessionContextGroupClient;\n_SessionContextGroupClient_clientPromise = new WeakMap();\n\nvar fdc31_2 = {};\n\nvar fdc3Common = {};\n\nvar utils$2 = {};\n\nvar PrivateChannelClient$1 = {};\n\nvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (commonjsGlobal && commonjsGlobal.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (commonjsGlobal && commonjsGlobal.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nObject.defineProperty(PrivateChannelClient$1, \"__esModule\", { value: true });\nPrivateChannelClient$1.PrivateChannelClient = void 0;\nconst utils$1 = __importStar(utils$3);\nclass PrivateChannelClient {\n    constructor(client, id) {\n        this.id = id;\n        this.client = client;\n        this.listeners = new Map();\n    }\n    async broadcast(context) {\n        return this.client.dispatch('broadcast', { context });\n    }\n    async getCurrentContext(contextType) {\n        return this.client.dispatch('getCurrentContext', { contextType });\n    }\n    async addContextListener(contextType, handler) {\n        if (typeof handler !== 'function') {\n            throw new Error(\"Non-function argument passed to the second parameter 'handler'. Be aware that the argument order does not match the FDC3 standard.\");\n        }\n        let handlerId;\n        if (contextType) {\n            handlerId = `contextHandler:invoke-${this.id}-${contextType}-${utils$1.generateId()}`;\n        }\n        else {\n            handlerId = `contextHandler:invoke-${this.id}-${utils$1.generateId()}`;\n        }\n        this.client.register(handlerId, utils$1.wrapContextHandler(handler, handlerId));\n        const listener = { unsubscribe: await this.createContextUnsubscribeCb(handlerId) };\n        this.listeners.set(handlerId, listener);\n        await this.client.dispatch(`contextHandlerAdded`, { handlerId, contextType });\n        return listener;\n    }\n    createNonStandardUnsubscribeCb(handlerId) {\n        return async () => {\n            this.client.remove(handlerId);\n            this.listeners.delete(handlerId);\n            await this.client.dispatch('nonStandardHandlerRemoved', { handlerId });\n        };\n    }\n    createContextUnsubscribeCb(handlerId) {\n        return async () => {\n            this.client.remove(handlerId);\n            this.listeners.delete(handlerId);\n            await this.client.dispatch('contextHandlerRemoved', { handlerId });\n        };\n    }\n    onAddContextListener(handler) {\n        const handlerId = `onContextHandlerAdded:invoke-${this.id}-${utils$1.generateId()}`;\n        this.client.register(handlerId, handler);\n        const listener = { unsubscribe: this.createNonStandardUnsubscribeCb(handlerId) };\n        this.listeners.set(handlerId, listener);\n        this.client.dispatch(`onAddContextHandlerAdded`, { handlerId });\n        return listener;\n    }\n    onDisconnect(handler) {\n        const handlerId = `onDisconnect:invoke-${this.id}-${utils$1.generateId()}`;\n        this.client.register(handlerId, handler);\n        const listener = { unsubscribe: this.createNonStandardUnsubscribeCb(handlerId) };\n        this.listeners.set(handlerId, listener);\n        this.client.dispatch(`onDisconnectHandlerAdded`, { handlerId });\n        return listener;\n    }\n    onUnsubscribe(handler) {\n        const handlerId = `onUnsubscribe:invoke-${this.id}-${utils$1.generateId()}`;\n        this.client.register(handlerId, handler);\n        const listener = { unsubscribe: this.createNonStandardUnsubscribeCb(handlerId) };\n        this.listeners.set(handlerId, listener);\n        this.client.dispatch(`onUnsubscribeHandlerAdded`, { handlerId });\n        return listener;\n    }\n    async cleanUpAllSubs() {\n        const listenerUnsubscribers = Array.from(this.listeners.keys());\n        listenerUnsubscribers.forEach((handlerId) => {\n            this.client.remove(handlerId);\n            this.listeners.delete(handlerId);\n        });\n    }\n    async disconnect() {\n        try {\n            await this.client.dispatch('clientDisconnecting');\n            await this.cleanUpAllSubs();\n            await this.client.disconnect();\n        }\n        catch (error) {\n            throw new Error(error.message);\n        }\n    }\n}\nPrivateChannelClient$1.PrivateChannelClient = PrivateChannelClient;\n\n(function (exports) {\n\tvar __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {\n\t    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n\t};\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\texports.getIntentResolution = exports.isChannel = exports.isContext = exports.connectPrivateChannel = exports.buildAppChannelObject = exports.buildPrivateChannelObject = exports.ChannelError = exports.ResultError = exports.UnsupportedChannelApiError = exports.getUnsupportedChannelApis = void 0;\n\tconst utils_1 = utils$3;\n\tconst PrivateChannelClient_1 = PrivateChannelClient$1;\n\tconst isEqual_1 = __importDefault(require$$3);\n\tconst getUnsupportedChannelApis = (channelType) => {\n\t    return {\n\t        addContextListener: () => {\n\t            throw new UnsupportedChannelApiError('Channel.addContextListener', channelType);\n\t        },\n\t        broadcast: () => {\n\t            throw new UnsupportedChannelApiError('Channel.broadcast', channelType);\n\t        },\n\t        getCurrentContext: () => {\n\t            throw new UnsupportedChannelApiError('Channel.getCurrentContext', channelType);\n\t        }\n\t    };\n\t};\n\texports.getUnsupportedChannelApis = getUnsupportedChannelApis;\n\tclass UnsupportedChannelApiError extends Error {\n\t    constructor(apiName, channelType = 'System') {\n\t        super(apiName);\n\t        this.message = `Calling ${apiName} on an instance of a ${channelType} Channel returned by fdc3.get${channelType}Channels is not supported. If you would like to use a ${channelType} Channel, please use fdc3.joinChannel, fdc3.addContextListener, and fdc3.broadcast instead.`;\n\t    }\n\t}\n\texports.UnsupportedChannelApiError = UnsupportedChannelApiError;\n\tvar ResultError;\n\t(function (ResultError) {\n\t    /** Returned if the `IntentHandler` exited without returning a Promise or that\n\t     *  Promise was not resolved with a Context or Channel object.\n\t     */\n\t    ResultError[\"NoResultReturned\"] = \"NoResultReturned\";\n\t    /** Returned if the `IntentHandler` function processing the raised intent\n\t     *  throws an error or rejects the Promise it returned.\n\t     */\n\t    ResultError[\"IntentHandlerRejected\"] = \"IntentHandlerRejected\";\n\t})(ResultError = exports.ResultError || (exports.ResultError = {}));\n\t(function (ChannelError) {\n\t    /** Returned if the specified channel is not found when attempting to join a\n\t     *  channel via the `joinUserChannel` function of the DesktopAgent (`fdc3`).\n\t     */\n\t    ChannelError[\"NoChannelFound\"] = \"NoChannelFound\";\n\t    /** SHOULD be returned when a request to join a user channel or to a retrieve\n\t     *  a Channel object via the `joinUserChannel` or `getOrCreateChannel` methods\n\t     *  of the DesktopAgent (`fdc3`) object is denied.\n\t     */\n\t    ChannelError[\"AccessDenied\"] = \"AccessDenied\";\n\t    /** SHOULD be returned when a channel cannot be created or retrieved via the\n\t     *  `getOrCreateChannel` method of the DesktopAgent (`fdc3`).\n\t     */\n\t    ChannelError[\"CreationFailed\"] = \"CreationFailed\";\n\t})(exports.ChannelError || (exports.ChannelError = {}));\n\tconst buildPrivateChannelObject = (privateChannelClient) => {\n\t    let clientDisconnected = false;\n\t    const checkIfClientDisconnected = () => {\n\t        if (clientDisconnected) {\n\t            throw new Error('Private Channel Client has been disconnected from the Private Channel');\n\t        }\n\t    };\n\t    return {\n\t        id: privateChannelClient.id,\n\t        type: 'private',\n\t        broadcast: async (context) => {\n\t            checkIfClientDisconnected();\n\t            return privateChannelClient.broadcast(context);\n\t        },\n\t        getCurrentContext: async (contextType) => {\n\t            checkIfClientDisconnected();\n\t            return privateChannelClient.getCurrentContext(contextType);\n\t        },\n\t        // @ts-expect-error TODO [CORE-1524]\n\t        addContextListener: async (contextType, handler) => {\n\t            checkIfClientDisconnected();\n\t            let handlerInUse = handler;\n\t            let contextTypeInUse = contextType;\n\t            if (typeof contextType === 'function') {\n\t                console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');\n\t                handlerInUse = contextType;\n\t                contextTypeInUse = null;\n\t            }\n\t            const listener = privateChannelClient.addContextListener(contextTypeInUse, handlerInUse);\n\t            return listener;\n\t        },\n\t        onAddContextListener: (handler) => {\n\t            checkIfClientDisconnected();\n\t            return privateChannelClient.onAddContextListener(handler);\n\t        },\n\t        disconnect: async () => {\n\t            checkIfClientDisconnected();\n\t            clientDisconnected = true;\n\t            return privateChannelClient.disconnect();\n\t        },\n\t        onDisconnect: (handler) => {\n\t            checkIfClientDisconnected();\n\t            return privateChannelClient.onDisconnect(handler);\n\t        },\n\t        onUnsubscribe: (handler) => {\n\t            checkIfClientDisconnected();\n\t            return privateChannelClient.onUnsubscribe(handler);\n\t        }\n\t    };\n\t};\n\texports.buildPrivateChannelObject = buildPrivateChannelObject;\n\tconst buildAppChannelObject = (sessionContextGroup) => {\n\t    return {\n\t        id: sessionContextGroup.id,\n\t        type: 'app',\n\t        broadcast: sessionContextGroup.setContext,\n\t        getCurrentContext: async (contextType) => {\n\t            const context = await sessionContextGroup.getCurrentContext(contextType);\n\t            return context === undefined ? null : context;\n\t        },\n\t        // @ts-expect-error TODO [CORE-1524]\n\t        addContextListener: (contextType, handler) => {\n\t            let realHandler;\n\t            let realType;\n\t            if (typeof contextType === 'function') {\n\t                console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');\n\t                realHandler = contextType;\n\t            }\n\t            else {\n\t                realHandler = handler;\n\t                if (typeof contextType === 'string') {\n\t                    realType = contextType;\n\t                }\n\t            }\n\t            const listener = (async () => {\n\t                let first = true;\n\t                const currentContext = await sessionContextGroup.getCurrentContext(realType);\n\t                const wrappedHandler = (context, contextMetadata) => {\n\t                    if (first) {\n\t                        first = false;\n\t                        if ((0, isEqual_1.default)(currentContext, context)) {\n\t                            return;\n\t                        }\n\t                    }\n\t                    // eslint-disable-next-line consistent-return\n\t                    return realHandler(context, contextMetadata);\n\t                };\n\t                return sessionContextGroup.addContextHandler(wrappedHandler, realType);\n\t            })();\n\t            return {\n\t                ...listener,\n\t                unsubscribe: () => listener.then((l) => l.unsubscribe())\n\t            };\n\t        }\n\t    };\n\t};\n\texports.buildAppChannelObject = buildAppChannelObject;\n\tconst connectPrivateChannel = async (channelId) => {\n\t    try {\n\t        const channelClient = await fin.InterApplicationBus.Channel.connect(channelId);\n\t        const privateChannelClient = new PrivateChannelClient_1.PrivateChannelClient(channelClient, channelId);\n\t        return (0, exports.buildPrivateChannelObject)(privateChannelClient);\n\t    }\n\t    catch (error) {\n\t        throw new Error(`Private Channel with id: ${channelId} doesn't exist`);\n\t    }\n\t};\n\texports.connectPrivateChannel = connectPrivateChannel;\n\tconst isContext = (context) => {\n\t    if (context && typeof context === 'object' && 'type' in context) {\n\t        const { type } = context;\n\t        return typeof type === 'string';\n\t    }\n\t    return false;\n\t};\n\texports.isContext = isContext;\n\tconst isChannel = (channel) => {\n\t    if (channel && typeof channel === 'object' && 'type' in channel && 'id' in channel) {\n\t        const { type, id } = channel;\n\t        return typeof type === 'string' && typeof id === 'string' && (type === 'app' || type === 'private');\n\t    }\n\t    return false;\n\t};\n\texports.isChannel = isChannel;\n\tconst getIntentResolution = async (interopModule, context, app, intent) => {\n\t    // Generate an ID to make a session context group with. We will pass that ID to the Broker.\n\t    // The broker will then setContext on that session context group later with our Intent Result,\n\t    const guid = (0, utils_1.generateId)(); // TODO make this undefined in web\n\t    // Promise we'll use in getResult\n\t    const getResultPromise = new Promise((resolve, reject) => {\n\t        fin.InterApplicationBus.subscribe({ uuid: '*' }, guid, (intentResult) => {\n\t            resolve(intentResult);\n\t        }).catch(() => reject(new Error('getResult is not supported in this environment')));\n\t    });\n\t    // Adding the intentResolutionResultId to the intentObj. Because fireIntent only accepts a single arg, we have to slap it in here.\n\t    const metadata = app ? { target: app, intentResolutionResultId: guid } : { intentResolutionResultId: guid };\n\t    const intentObj = intent ? { name: intent, context, metadata } : { ...context, metadata };\n\t    // Set up the getResult call.\n\t    const getResult = async () => {\n\t        let intentResult = await getResultPromise;\n\t        if (!intentResult || typeof intentResult !== 'object') {\n\t            throw new Error(ResultError.NoResultReturned);\n\t        }\n\t        const { error } = intentResult;\n\t        if (error) {\n\t            throw new Error(ResultError.IntentHandlerRejected);\n\t        }\n\t        if ((0, exports.isChannel)(intentResult)) {\n\t            const { id, type } = intentResult;\n\t            switch (type) {\n\t                case 'private': {\n\t                    intentResult = await (0, exports.connectPrivateChannel)(id);\n\t                    break;\n\t                }\n\t                case 'app': {\n\t                    const sessionContextGroup = await interopModule.joinSessionContextGroup(id);\n\t                    intentResult = (0, exports.buildAppChannelObject)(sessionContextGroup);\n\t                    break;\n\t                }\n\t            }\n\t        }\n\t        else if (!(0, exports.isContext)(intentResult)) {\n\t            throw new Error(ResultError.NoResultReturned);\n\t        }\n\t        return intentResult;\n\t    };\n\t    // Finally fire the intent.\n\t    const intentResolutionInfoFromBroker = intent\n\t        ? await interopModule.fireIntent(intentObj)\n\t        : await interopModule.fireIntentForContext(intentObj);\n\t    if (typeof intentResolutionInfoFromBroker !== 'object') {\n\t        return {\n\t            source: {\n\t                appId: '',\n\t                instanceId: ''\n\t            },\n\t            intent: '',\n\t            version: '2.0',\n\t            getResult\n\t        };\n\t    }\n\t    return { ...intentResolutionInfoFromBroker, getResult };\n\t};\n\texports.getIntentResolution = getIntentResolution; \n} (utils$2));\n\nvar hasRequiredFdc3Common;\n\nfunction requireFdc3Common () {\n\tif (hasRequiredFdc3Common) return fdc3Common;\n\thasRequiredFdc3Common = 1;\n\tvar __classPrivateFieldGet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n\t    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n\t    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n\t    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n\t};\n\tvar __classPrivateFieldSet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n\t    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n\t    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n\t    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n\t    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n\t};\n\tvar __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {\n\t    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n\t};\n\tvar _FDC3ModuleBase_producer;\n\tObject.defineProperty(fdc3Common, \"__esModule\", { value: true });\n\tfdc3Common.FDC3ModuleBase = void 0;\n\tconst utils_1 = utils$2;\n\tconst utils_2 = utils$3;\n\tconst InteropClient_1 = requireInteropClient();\n\tconst isEqual_1 = __importDefault(require$$3);\n\tclass FDC3ModuleBase {\n\t    get client() {\n\t        return __classPrivateFieldGet(this, _FDC3ModuleBase_producer, \"f\").call(this);\n\t    }\n\t    get fin() {\n\t        return this.wire.getFin();\n\t    }\n\t    // eslint-disable-next-line no-useless-constructor\n\t    constructor(producer, wire) {\n\t        this.wire = wire;\n\t        _FDC3ModuleBase_producer.set(this, void 0);\n\t        __classPrivateFieldSet(this, _FDC3ModuleBase_producer, producer, \"f\");\n\t    }\n\t    /**\n\t     * Broadcasts a context for the channel of the current entity.\n\t     * @param context - New context to set.\n\t     *\n\t     * @tutorial fdc3.broadcast\n\t     * @static\n\t     */\n\t    async broadcast(context) {\n\t        this.wire.sendAction('fdc3-broadcast').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return this.client.setContext(context);\n\t    }\n\t    /**\n\t     * Launches an app with target information, which can either be a string or an AppMetadata object.\n\t     * @param app\n\t     * @param context\n\t     *\n\t     * @tutorial fdc3.open\n\t     */\n\t    async _open(app, context) {\n\t        this.wire.sendAction('fdc3-open').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        try {\n\t            return await InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'fdc3Open', { app, context });\n\t        }\n\t        catch (error) {\n\t            const errorToThrow = error.message === utils_2.BROKER_ERRORS.fdc3Open ? 'ResolverUnavailable' : error.message;\n\t            throw new Error(errorToThrow);\n\t        }\n\t    }\n\t    async _getChannels() {\n\t        const channels = await this.client.getContextGroups();\n\t        // fdc3 implementation of getSystemChannels returns an array of channels, have to decorate over\n\t        // this so people know that these APIs are not supported\n\t        return channels.map((channel) => {\n\t            return { ...channel, type: 'system', ...(0, utils_1.getUnsupportedChannelApis)() };\n\t        });\n\t    }\n\t    /**\n\t     * Returns a Channel object for the specified channel, creating it as an App Channel if it does not exist.\n\t     * @param channelId\n\t     *\n\t     * @tutorial fdc3.getOrCreateChannel\n\t     */\n\t    async getOrCreateChannel(channelId) {\n\t        this.wire.sendAction('fdc3-get-or-create-channel').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const systemChannels = await this._getChannels();\n\t        const userChannel = systemChannels.find((channel) => channel.id === channelId);\n\t        if (userChannel) {\n\t            return { ...userChannel, type: 'system', ...(0, utils_1.getUnsupportedChannelApis)() };\n\t        }\n\t        try {\n\t            const sessionContextGroup = await this.client.joinSessionContextGroup(channelId);\n\t            return (0, utils_1.buildAppChannelObject)(sessionContextGroup);\n\t        }\n\t        catch (error) {\n\t            console.error(error.message);\n\t            throw new Error(utils_1.ChannelError.CreationFailed);\n\t        }\n\t    }\n\t    /**\n\t     * Returns the Interop-Broker-defined context groups available for an entity to join.\n\t     *\n\t     * @tutorial fdc3.getSystemChannels\n\t     * @static\n\t     */\n\t    async getSystemChannels() {\n\t        this.wire.sendAction('fdc3-get-system-channels').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return this._getChannels();\n\t    }\n\t    /**\n\t     * Join all Interop Clients at the given identity to context group `contextGroupId`.\n\t     * If no target is specified, it adds the sender to the context group.\n\t     * Because multiple Channel connections/Interop Clients can potentially exist at a `uuid`/`name` combo, we currently join all Channel connections/Interop Clients at the given identity to the context group.\n\t     * If an `endpointId` is provided (which is unlikely, unless the call is coming from an external adapter), then we only join that single connection to the context group.\n\t     * For all intents and purposes, there will only be 1 connection present in Platform and Browser implementations, so this point is more-or-less moot.\n\t     * @param channelId - Id of the context group.\n\t     *\n\t     * @tutorial fdc3.joinChannel\n\t     * @static\n\t     */\n\t    async joinChannel(channelId) {\n\t        this.wire.sendAction('fdc3-join-channel').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        try {\n\t            return await this.client.joinContextGroup(channelId);\n\t        }\n\t        catch (error) {\n\t            if (error.message === utils_2.BROKER_ERRORS.joinSessionContextGroupWithJoinContextGroup) {\n\t                console.error('The Channel you have tried to join is an App Channel. Custom Channels can only be defined by the Interop Broker through code or manifest configuration. Please use getOrCreateChannel.');\n\t            }\n\t            else {\n\t                console.error(error.message);\n\t            }\n\t            if (error.message.startsWith('Attempting to join a context group that does not exist')) {\n\t                throw new Error(utils_1.ChannelError.NoChannelFound);\n\t            }\n\t            throw new Error(utils_1.ChannelError.AccessDenied);\n\t        }\n\t    }\n\t    /**\n\t     * Returns the Channel that the entity is subscribed to. Returns null if not joined to a channel.\n\t     *\n\t     * @tutorial fdc3.getCurrentChannel\n\t     */\n\t    async getCurrentChannel() {\n\t        this.wire.sendAction('fdc3-get-current-channel').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const currentContextGroupInfo = await this.getCurrentContextGroupInfo();\n\t        if (!currentContextGroupInfo) {\n\t            return null;\n\t        }\n\t        return this.buildChannelObject(currentContextGroupInfo);\n\t    }\n\t    /**\n\t     * Removes the specified target from a context group.\n\t     * If no target is specified, it removes the sender from their context group.\n\t     *\n\t     * @tutorial fdc3.leaveCurrentChannel\n\t     * @static\n\t     */\n\t    async leaveCurrentChannel() {\n\t        this.wire.sendAction('fdc3-leave-current-channel').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        return this.client.removeFromContextGroup();\n\t    }\n\t    // utils\n\t    // eslint-disable-next-line class-methods-use-this\n\t    async getCurrentContextGroupInfo() {\n\t        const contextGroups = await this.client.getContextGroups();\n\t        const clientsInCtxGroupsPromise = contextGroups.map(async (ctxGroup) => {\n\t            return this.client.getAllClientsInContextGroup(ctxGroup.id);\n\t        });\n\t        const clientsInCtxGroups = await Promise.all(clientsInCtxGroupsPromise);\n\t        const clientIdx = clientsInCtxGroups.findIndex((clientIdentityArr) => {\n\t            return clientIdentityArr.some((clientIdentity) => {\n\t                const { uuid, name } = clientIdentity;\n\t                return this.wire.me.uuid === uuid && this.wire.me.name === name;\n\t            });\n\t        });\n\t        return contextGroups[clientIdx];\n\t    }\n\t    async buildChannelObject(currentContextGroupInfo) {\n\t        // @ts-expect-error\n\t        return {\n\t            ...currentContextGroupInfo,\n\t            type: 'system',\n\t            addContextListener: (...[contextType, handler]) => {\n\t                let realHandler;\n\t                let realType;\n\t                if (typeof contextType === 'function') {\n\t                    console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');\n\t                    realHandler = contextType;\n\t                }\n\t                else {\n\t                    realHandler = handler;\n\t                    if (typeof contextType === 'string') {\n\t                        realType = contextType;\n\t                    }\n\t                }\n\t                const listener = (async () => {\n\t                    let first = true;\n\t                    const currentContext = await this.client.getCurrentContext(realType);\n\t                    const wrappedHandler = (context, contextMetadata) => {\n\t                        if (first) {\n\t                            first = false;\n\t                            if ((0, isEqual_1.default)(currentContext, context)) {\n\t                                return;\n\t                            }\n\t                        }\n\t                        // eslint-disable-next-line consistent-return\n\t                        return realHandler(context, contextMetadata);\n\t                    };\n\t                    return this.client.addContextHandler(wrappedHandler, realType);\n\t                })();\n\t                // @ts-expect-error TODO [CORE-1524]\n\t                return {\n\t                    ...listener,\n\t                    unsubscribe: () => listener.then((l) => l.unsubscribe())\n\t                };\n\t            },\n\t            broadcast: this.broadcast.bind(this),\n\t            // @ts-expect-error Typescript fails to infer the returntype is a Promise\n\t            getCurrentContext: async (contextType) => {\n\t                const context = await this.client.getCurrentContext(contextType);\n\t                // @ts-expect-error Typescript fails to infer the returntype is a Promise\n\t                return context === undefined ? null : context;\n\t            }\n\t        };\n\t    }\n\t}\n\tfdc3Common.FDC3ModuleBase = FDC3ModuleBase;\n\t_FDC3ModuleBase_producer = new WeakMap();\n\treturn fdc3Common;\n}\n\nvar hasRequiredFdc31_2;\n\nfunction requireFdc31_2 () {\n\tif (hasRequiredFdc31_2) return fdc31_2;\n\thasRequiredFdc31_2 = 1;\n\tObject.defineProperty(fdc31_2, \"__esModule\", { value: true });\n\tfdc31_2.Fdc3Module = void 0;\n\tconst utils_1 = utils$3;\n\tconst fdc3_common_1 = requireFdc3Common();\n\t/**\n\t * @version 1.2\n\t * The FDC3 Client Library provides a set APIs to be used for FDC3 compliance,\n\t * while using our Interop API under the hood. In order to use this set of APIs\n\t * you will need to set up your own {@link InteropBroker InteropBroker} or use a Platform application, which does the setup for you. Refer to our documentation on\n\t * our {@link https://developers.openfin.co/of-docs/docs/enable-color-linking Interop API}.\n\t *\n\t * To enable the FDC3 APIs in a {@link Window Window} or {@link View View}, add the fdc3InteropApi\n\t * property to its options:\n\t *\n\t * ```js\n\t * {\n\t *     autoShow: false,\n\t *     saveWindowState: true,\n\t *     url: 'https://openfin.co',\n\t *     fdc3InteropApi: '1.2'\n\t * }\n\t * ```\n\t *\n\t * If using a {@link Platform Platform } application, you can set this property in defaultWindowOptions and defaultViewOptions.\n\t *\n\t * In order to ensure that the FDC3 Api is ready before use, you can use the 'fdc3Ready' event fired on the DOM Window object:\n\t *\n\t * ```js\n\t * function fdc3Action() {\n\t *     // Make some fdc3 API calls here\n\t * }\n\t *\n\t * if (window.fdc3) {\n\t *    fdc3Action();\n\t * } else {\n\t *    window.addEventListener('fdc3Ready', fdc3Action);\n\t * }\n\t * ```\n\t */\n\tclass Fdc3Module extends fdc3_common_1.FDC3ModuleBase {\n\t    async open(app, context) {\n\t        // eslint-disable-next-line no-underscore-dangle\n\t        await super._open(app, context);\n\t    }\n\t    /**\n\t     * Add a context handler for incoming context. If an entity is part of a context group, and then sets its context handler, it will receive all of its declared contexts. If you wish to listen for all incoming contexts, pass `null` for the contextType argument.\n\t     * @param contextType - The type of context you wish to handle.\n\t     * @param handler - Handler for incoming context.\n\t     *\n\t     * @tutorial fdc3.addContextListener\n\t     * @static\n\t     */\n\t    // @ts-expect-error TODO [CORE-1524]\n\t    addContextListener(contextType, handler) {\n\t        this.wire.sendAction('fdc3-add-context-listener').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        let listener;\n\t        if (typeof contextType === 'function') {\n\t            console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');\n\t            listener = this.client.addContextHandler(contextType);\n\t        }\n\t        else {\n\t            listener = this.client.addContextHandler(handler, contextType === null ? undefined : contextType);\n\t        }\n\t        return {\n\t            ...listener,\n\t            unsubscribe: () => listener.then((l) => l.unsubscribe())\n\t        };\n\t    }\n\t    /**\n\t     * Adds a listener for incoming Intents.\n\t     * @param intent - Name of the Intent\n\t     * @param handler - Handler for incoming Intent\n\t     *\n\t     * @tutorial fdc3.addIntentListener\n\t     * @static\n\t     */\n\t    addIntentListener(intent, handler) {\n\t        this.wire.sendAction('fdc3-add-intent-listener').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const contextHandler = (raisedIntent) => {\n\t            const { context, metadata: intentMetadata } = raisedIntent;\n\t            const { metadata } = context;\n\t            const intentResolutionResultId = intentMetadata?.intentResolutionResultId || metadata?.intentResolutionResultId;\n\t            if (intentResolutionResultId) {\n\t                this.fin.InterApplicationBus.publish(intentResolutionResultId, null).catch(() => null);\n\t            }\n\t            handler(raisedIntent.context);\n\t        };\n\t        const listener = this.client.registerIntentHandler(contextHandler, intent, {\n\t            fdc3Version: '1.2'\n\t        });\n\t        return {\n\t            ...listener,\n\t            unsubscribe: () => listener.then((l) => l.unsubscribe())\n\t        };\n\t    }\n\t    /**\n\t     * Raises a specific intent.\n\t     * @param intent Name of the Intent.\n\t     * @param context Context associated with the Intent.\n\t     * @param  app App that will resolve the Intent. This is added as metadata to the Intent. Can be accessed by the app provider in {@link InteropBroker#handleFiredIntent InteropBroker.handleFiredIntent}.\n\t     *\n\t     * @tutorial fdc3.raiseIntent\n\t     * @static\n\t     */\n\t    async raiseIntent(intent, context, app) {\n\t        this.wire.sendAction('fdc3-raise-intent').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const intentObj = app\n\t            ? { name: intent, context, metadata: { target: app } }\n\t            : { name: intent, context };\n\t        try {\n\t            return await this.client.fireIntent(intentObj);\n\t        }\n\t        catch (error) {\n\t            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fireIntent ? 'ResolverUnavailable' : error.message;\n\t            throw new Error(errorToThrow);\n\t        }\n\t    }\n\t    /**\n\t     * Find out more information about a particular intent by passing its name, and optionally its context.\n\t     * @param intent Name of the Intent\n\t     * @param context\n\t     *\n\t     * @tutorial fdc3.findIntent\n\t     */\n\t    async findIntent(intent, context) {\n\t        this.wire.sendAction('fdc3-find-intent').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        try {\n\t            return await this.client.getInfoForIntent({ name: intent, context });\n\t        }\n\t        catch (error) {\n\t            const errorToThrow = error.message === utils_1.BROKER_ERRORS.getInfoForIntent ? 'ResolverUnavailable' : error.message;\n\t            throw new Error(errorToThrow);\n\t        }\n\t    }\n\t    /**\n\t     * Find all the available intents for a particular context.\n\t     * @param context\n\t     *\n\t     * @tutorial fdc3.findIntentsByContext\n\t     */\n\t    async findIntentsByContext(context) {\n\t        this.wire.sendAction('fdc3-find-intents-by-context').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        try {\n\t            return await this.client.getInfoForIntentsByContext(context);\n\t        }\n\t        catch (error) {\n\t            const errorToThrow = error.message === utils_1.BROKER_ERRORS.getInfoForIntentsByContext ? 'ResolverUnavailable' : error.message;\n\t            throw new Error(errorToThrow);\n\t        }\n\t    }\n\t    /**\n\t     * Finds and raises an intent against a target app based purely on context data.\n\t     * @param context\n\t     * @param app\n\t     *\n\t     * @tutorial fdc3.raiseIntentForContext\n\t     */\n\t    async raiseIntentForContext(context, app) {\n\t        this.wire.sendAction('fdc3-raise-intent-for-context').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        try {\n\t            return await this.client.fireIntentForContext({ ...context, metadata: { target: app } });\n\t        }\n\t        catch (error) {\n\t            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fireIntentForContext ? 'ResolverUnavailable' : error.message;\n\t            throw new Error(errorToThrow);\n\t        }\n\t    }\n\t    /**\n\t     * Returns a Channel object for the specified channel, creating it as an App Channel if it does not exist.\n\t     * @param channelId\n\t     *\n\t     * @tutorial fdc3.getOrCreateChannel\n\t     */\n\t    async getOrCreateChannel(channelId) {\n\t        return super.getOrCreateChannel(channelId);\n\t    }\n\t    /**\n\t     * Returns metadata relating to the FDC3 object and its provider, including the supported version of the FDC3 specification and the name of the provider of the implementation.\n\t     *\n\t     * @tutorial fdc3.getInfo\n\t     */\n\t    getInfo() {\n\t        this.wire.sendAction('fdc3-get-info').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const version = this.wire.environment.getAdapterVersionSync();\n\t        return {\n\t            providerVersion: version,\n\t            provider: `openfin-${this.wire.me.uuid}`,\n\t            fdc3Version: '1.2'\n\t        };\n\t    }\n\t}\n\tfdc31_2.Fdc3Module = Fdc3Module;\n\treturn fdc31_2;\n}\n\nvar fdc32_0 = {};\n\nvar hasRequiredFdc32_0;\n\nfunction requireFdc32_0 () {\n\tif (hasRequiredFdc32_0) return fdc32_0;\n\thasRequiredFdc32_0 = 1;\n\tObject.defineProperty(fdc32_0, \"__esModule\", { value: true });\n\tfdc32_0.Fdc3Module2 = void 0;\n\tconst fdc3_common_1 = requireFdc3Common();\n\tconst utils_1 = utils$3;\n\tconst InteropClient_1 = requireInteropClient();\n\tconst utils_2 = utils$2;\n\tconst PrivateChannelClient_1 = PrivateChannelClient$1;\n\t/**\n\t * @version 2.0\n\t * The FDC3 Client Library provides a set APIs to be used for FDC3 compliance,\n\t * while using our Interop API under the hood. In order to use this set of APIs\n\t * you will need to set up your own {@link InteropBroker InteropBroker} or use a Platform application, which does the setup for you. Refer to our documentation on\n\t * our {@link https://developers.openfin.co/of-docs/docs/enable-context-sharing Interop API}.\n\t *\n\t * To enable the FDC3 APIs in a {@link Window Window} or {@link View View}, add the fdc3InteropApi\n\t * property to its options:\n\t *\n\t * ```js\n\t * {\n\t *     autoShow: false,\n\t *     saveWindowState: true,\n\t *     url: 'https://openfin.co',\n\t *     fdc3InteropApi: '2.0'\n\t * }\n\t * ```\n\t *\n\t * If using a {@link Platform Platform } application, you can set this property in defaultWindowOptions and defaultViewOptions.\n\t *\n\t * In order to ensure that the FDC3 Api is ready before use, you can use the 'fdc3Ready' event fired on the DOM Window object:\n\t *\n\t * ```js\n\t * function fdc3Action() {\n\t *     // Make some fdc3 API calls here\n\t * }\n\t *\n\t * if (window.fdc3) {\n\t *    fdc3Action();\n\t * } else {\n\t *    window.addEventListener('fdc3Ready', fdc3Action);\n\t * }\n\t * ```\n\t */\n\tclass Fdc3Module2 extends fdc3_common_1.FDC3ModuleBase {\n\t    /**\n\t     * Launches an app, specified via an AppIdentifier object.\n\t     * @param app\n\t     * @param context\n\t     *\n\t     * @tutorial fdc3.open\n\t     */\n\t    async open(app, context) {\n\t        if (typeof app === 'string') {\n\t            console.warn('Passing a string as the app parameter is deprecated, please use an AppIdentifier ({ appId: string; instanceId?: string }).');\n\t        }\n\t        // eslint-disable-next-line no-underscore-dangle\n\t        return super._open(app, context);\n\t    }\n\t    /**\n\t     * Find all the available instances for a particular application.\n\t     * @param app\n\t     *\n\t     * @tutorial fdc3v2.findInstances\n\t     */\n\t    async findInstances(app) {\n\t        this.wire.sendAction('fdc3-find-instances').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        try {\n\t            return await InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'fdc3FindInstances', app);\n\t        }\n\t        catch (error) {\n\t            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fdc3FindInstances ? 'ResolverUnavailable' : error.message;\n\t            throw new Error(errorToThrow);\n\t        }\n\t    }\n\t    /**\n\t     * Retrieves the AppMetadata for an AppIdentifier, which provides additional metadata (such as icons, a title and description) from the App Directory record for the application, that may be used for display purposes.\n\t     * @param app\n\t     *\n\t     * @tutorial fdc3v2.getAppMetadata\n\t     */\n\t    async getAppMetadata(app) {\n\t        this.wire.sendAction('fdc3-get-app-metadata').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        try {\n\t            return await InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'fdc3GetAppMetadata', app);\n\t        }\n\t        catch (error) {\n\t            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fdc3GetAppMetadata ? 'ResolverUnavailable' : error.message;\n\t            throw new Error(errorToThrow);\n\t        }\n\t    }\n\t    /**\n\t     * Add a context handler for incoming context. If an entity is part of a context group, and then sets its context handler, it will receive all of its declared contexts. If you wish to listen for all incoming contexts, pass `null` for the contextType argument.\n\t     * @param contextType\n\t     * @param handler\n\t     *\n\t     * @tutorial fdc3.addContextListener\n\t     */\n\t    // @ts-expect-error TODO [CORE-1524]\n\t    async addContextListener(contextType, handler) {\n\t        this.wire.sendAction('fdc3-add-context-listener').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        // The FDC3 ContextHandler only expects the context and optional ContextMetadata, so we wrap the handler\n\t        // here so it only gets passed these parameters\n\t        const getWrappedHandler = (handlerToWrap) => {\n\t            return (context) => {\n\t                const { contextMetadata, ...rest } = context;\n\t                const args = contextMetadata ? [{ ...rest }, contextMetadata] : [context, null];\n\t                handlerToWrap(...args);\n\t            };\n\t        };\n\t        let actualHandler = handler;\n\t        let wrappedHandler = getWrappedHandler(actualHandler);\n\t        if (typeof contextType === 'function') {\n\t            console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');\n\t            actualHandler = contextType;\n\t            wrappedHandler = getWrappedHandler(actualHandler);\n\t            return this.client.addContextHandler(wrappedHandler);\n\t        }\n\t        return this.client.addContextHandler(wrappedHandler, contextType === null ? undefined : contextType);\n\t    }\n\t    /**\n\t     * Find out more information about a particular intent by passing its name, and optionally its context and resultType.\n\t     * @param intent Name of the Intent\n\t     * @param context Context\n\t     * @param resultType The type of result returned for any intent specified during resolution.\n\t     *\n\t     * @tutorial fdc3.findIntent\n\t     */\n\t    async findIntent(intent, context, resultType) {\n\t        this.wire.sendAction('fdc3-find-intent').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        try {\n\t            return await this.client.getInfoForIntent({ name: intent, context, metadata: { resultType } });\n\t        }\n\t        catch (error) {\n\t            const errorToThrow = error.message === utils_1.BROKER_ERRORS.getInfoForIntent ? 'ResolverUnavailable' : error.message;\n\t            throw new Error(errorToThrow);\n\t        }\n\t    }\n\t    /**\n\t     * Find all the available intents for a particular context.\n\t     * @param context\n\t     * @param resultType The type of result returned for any intent specified during resolution.\n\t     *\n\t     * @tutorial fdc3v2.findIntentsByContext\n\t     */\n\t    async findIntentsByContext(context, resultType) {\n\t        this.wire.sendAction('fdc3-find-intents-by-context').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        const payload = resultType ? { context, metadata: { resultType } } : context;\n\t        try {\n\t            return await InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'fdc3v2FindIntentsByContext', payload);\n\t        }\n\t        catch (error) {\n\t            const errorToThrow = error.message === utils_1.BROKER_ERRORS.getInfoForIntentsByContext ? 'ResolverUnavailable' : error.message;\n\t            throw new Error(errorToThrow);\n\t        }\n\t    }\n\t    /**\n\t     * Raises a specific intent for resolution against apps registered with the desktop agent.\n\t     * @param intent Name of the Intent\n\t     * @param context Context associated with the Intent\n\t     * @param app\n\t     *\n\t     * @tutorial fdc3v2.raiseIntent\n\t     */\n\t    async raiseIntent(intent, context, app) {\n\t        this.wire.sendAction('fdc3-raise-intent').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        try {\n\t            if (typeof app === 'string') {\n\t                console.warn('Passing a string as the app parameter is deprecated, please use an AppIdentifier ({ appId: string; instanceId?: string }).');\n\t            }\n\t            return (0, utils_2.getIntentResolution)(this.client, context, app, intent);\n\t        }\n\t        catch (error) {\n\t            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fireIntent ? 'ResolverUnavailable' : error.message;\n\t            throw new Error(errorToThrow);\n\t        }\n\t    }\n\t    /**\n\t     * Finds and raises an intent against apps registered with the desktop agent based purely on the type of the context data.\n\t     * @param context Context associated with the Intent\n\t     * @param app\n\t     *\n\t     * @tutorial fdc3v2.raiseIntentForContext\n\t     */\n\t    async raiseIntentForContext(context, app) {\n\t        // TODO: We have to do the same thing we do for raiseIntent here as well.\n\t        this.wire.sendAction('fdc3-raise-intent-for-context').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        try {\n\t            if (typeof app === 'string') {\n\t                console.warn('Passing a string as the app parameter is deprecated, please use an AppIdentifier ({ appId: string; instanceId?: string }).');\n\t            }\n\t            return (0, utils_2.getIntentResolution)(this.client, context, app);\n\t        }\n\t        catch (error) {\n\t            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fireIntent ? 'ResolverUnavailable' : error.message;\n\t            throw new Error(errorToThrow);\n\t        }\n\t    }\n\t    /**\n\t     * Adds a listener for incoming intents.\n\t     * @param intent  Name of the Intent\n\t     * @param handler A callback that handles a context event and may return a promise of a Context or Channel object to be returned to the application that raised the intent.\n\t     *\n\t     * @tutorial fdc3.addIntentListener\n\t     */\n\t    async addIntentListener(intent, handler) {\n\t        this.wire.sendAction('fdc3-add-intent-listener').catch((e) => {\n\t            // we do not want to expose this error, just continue if this analytics-only call fails\n\t        });\n\t        if (typeof intent !== 'string') {\n\t            throw new Error('First argument must be an Intent name');\n\t        }\n\t        // The FDC3 Intenter handler only expects the context and contextMetadata to be passed to the handler,\n\t        // so we wrap it here and only pass those paramaters.\n\t        const contextHandler = async (raisedIntent) => {\n\t            let intentResult;\n\t            let intentResultToSend;\n\t            const { context, metadata: intentMetadata } = raisedIntent;\n\t            const { contextMetadata, metadata, ...rest } = context;\n\t            const intentResolutionResultId = intentMetadata?.intentResolutionResultId || metadata?.intentResolutionResultId;\n\t            try {\n\t                const newContext = metadata ? { metadata, ...rest } : { ...rest };\n\t                intentResult = await handler(newContext, contextMetadata);\n\t                intentResultToSend = intentResult;\n\t            }\n\t            catch (error) {\n\t                intentResult = error;\n\t                intentResultToSend = { error: true };\n\t            }\n\t            if (intentResolutionResultId) {\n\t                this.fin.InterApplicationBus.publish(intentResolutionResultId, intentResultToSend).catch(() => null);\n\t            }\n\t            if (intentResult instanceof Error) {\n\t                throw new Error(intentResult.message);\n\t            }\n\t            return intentResult;\n\t        };\n\t        return this.client.registerIntentHandler(contextHandler, intent, { fdc3Version: '2.0' });\n\t    }\n\t    /**\n\t     * Returns a Channel object for the specified channel, creating it as an App Channel if it does not exist.\n\t     * @param channelId\n\t     *\n\t     * @tutorial fdc3.getOrCreateChannel\n\t     */\n\t    async getOrCreateChannel(channelId) {\n\t        return super.getOrCreateChannel(channelId);\n\t    }\n\t    /**\n\t     * Returns a Channel with an auto-generated identity that is intended for private communication between applications. Primarily used to create channels that will be returned to other applications via an IntentResolution for a raised intent.\n\t     *\n\t     * @tutorial fdc3v2.createPrivateChannel\n\t     */\n\t    async createPrivateChannel() {\n\t        const channelId = (0, utils_1.generateId)();\n\t        await InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'createPrivateChannelProvider', { channelId });\n\t        const channelClient = await this.fin.InterApplicationBus.Channel.connect(channelId);\n\t        const newPrivateChannelClient = new PrivateChannelClient_1.PrivateChannelClient(channelClient, channelId);\n\t        return (0, utils_2.buildPrivateChannelObject)(newPrivateChannelClient);\n\t    }\n\t    /**\n\t     * Retrieves a list of the User Channels available for the app to join.\n\t     *\n\t     * @tutorial fdc3v2.getUserChannels\n\t     */\n\t    async getUserChannels() {\n\t        const channels = await this.client.getContextGroups();\n\t        // fdc3 implementation of getUserChannels returns on array of channels, have to decorate over\n\t        // this so people know that these APIs are not supported\n\t        return channels.map((channel) => {\n\t            // @ts-expect-error TODO [CORE-1524]\n\t            return { ...channel, type: 'user', ...(0, utils_2.getUnsupportedChannelApis)('User') };\n\t        });\n\t    }\n\t    /**\n\t     * Retrieves a list of the User Channels available for the app to join.\n\t     *\n\t     * @deprecated Please use {@link fdc3.getUserChannels fdc3.getUserChannels} instead\n\t     * @tutorial fdc3.getSystemChannels\n\t     */\n\t    async getSystemChannels() {\n\t        console.warn('This API has been deprecated. Please use fdc3.getUserChannels instead.');\n\t        return super.getSystemChannels();\n\t    }\n\t    /**\n\t     * Join an app to a specified User channel.\n\t     * @param channelId Channel name\n\t     *\n\t     * @tutorial fdc3v2.joinUserChannel\n\t     */\n\t    async joinUserChannel(channelId) {\n\t        return super.joinChannel(channelId);\n\t    }\n\t    /**\n\t     * Join an app to a specified User channel.\n\t     * @param channelId Channel name\n\t     * @deprecated Please use {@link fdc3.joinUserChannel fdc3.joinUserChannel} instead\n\t     *\n\t     * @tutorial fdc3.joinChannel\n\t     */\n\t    async joinChannel(channelId) {\n\t        console.warn('This API has been deprecated. Please use fdc3.joinUserChannel instead.');\n\t        return super.joinChannel(channelId);\n\t    }\n\t    /**\n\t     * Returns the Channel object for the current User channel membership\n\t     *\n\t     * @tutorial fdc3.getCurrentChannel\n\t     */\n\t    async getCurrentChannel() {\n\t        const currentChannel = await super.getCurrentChannel();\n\t        if (!currentChannel) {\n\t            return null;\n\t        }\n\t        return {\n\t            ...currentChannel,\n\t            type: 'user',\n\t            broadcast: this.broadcast.bind(this)\n\t        };\n\t    }\n\t    /**\n\t     * Retrieves information about the FDC3 implementation, including the supported version of the FDC3 specification, the name of the provider of the implementation, its own version number, details of whether optional API features are implemented and the metadata of the calling application according to the desktop agent.\n\t     * fdc3HandleGetInfo must be overridden in the InteropBroker so that the ImplementationMetadata will have the appMetadata info.\n\t     *\n\t     * @tutorial fdc3v2.getInfo\n\t     */\n\t    async getInfo() {\n\t        return InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'fdc3v2GetInfo', { fdc3Version: '2.0' });\n\t    }\n\t}\n\tfdc32_0.Fdc3Module2 = Fdc3Module2;\n\treturn fdc32_0;\n}\n\nvar hasRequiredInteropClient;\n\nfunction requireInteropClient () {\n\tif (hasRequiredInteropClient) return InteropClient;\n\thasRequiredInteropClient = 1;\n\tvar __classPrivateFieldSet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n\t    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n\t    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n\t    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n\t    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n\t};\n\tvar __classPrivateFieldGet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n\t    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n\t    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n\t    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n\t};\n\tvar __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {\n\t    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n\t};\n\tvar _InteropClient_clientPromise, _InteropClient_sessionContextGroups;\n\tObject.defineProperty(InteropClient, \"__esModule\", { value: true });\n\tInteropClient.InteropClient = void 0;\n\tconst base_1 = base;\n\tconst SessionContextGroupClient_1 = __importDefault(SessionContextGroupClient$1);\n\tconst fdc3_1_2_1 = requireFdc31_2();\n\tconst fdc3_2_0_1 = requireFdc32_0();\n\tconst utils_1 = utils$3;\n\t/**\n\t * The Interop Client API is broken up into two groups:\n\t *\n\t * **Content Facing APIs** - For Application Developers putting Views into a Platform Window, who care about Context. These are APIs that send out and receive the Context data that flows between applications. Think of this as the Water in the Interop Pipes.\n\t *\n\t * **Context Grouping APIs** - For Platform Developers, to add and remove Views to and from Context Groups. These APIs are utilized under-the-hood in Platforms, so they don't need to be used to participate in Interop. These are the APIs that decide which entities the context data flows between. Think of these as the valves or pipes that control the flow of Context Data for Interop.\n\t *\n\t * ---\n\t *\n\t * All APIs are available at the `fin.me.interop` namespace.\n\t *\n\t * ---\n\t *\n\t * **You only need 2 things to participate in Interop Context Grouping:**\n\t * * A Context Handler for incoming context: {@link InteropClient#addContextHandler addContextHandler(handler, contextType?)}\n\t * * Call setContext on your context group when you want to share context with other group members: {@link InteropClient#setContext setContext(context)}\n\t *\n\t * ---\n\t *\n\t * ##### Constructor\n\t * Returned by {@link Interop.connectSync Interop.connectSync}.\n\t *\n\t * ---\n\t *\n\t * ##### Interop methods intended for Views\n\t *\n\t *\n\t * **Context Groups API**\n\t *  * {@link InteropClient#addContextHandler addContextHandler(handler, contextType?)}\n\t *  * {@link InteropClient#setContext setContext(context)}\n\t *  * {@link InteropClient#getCurrentContext getCurrentContext(contextType?)}\n\t *  * {@link InteropClient#joinSessionContextGroup joinSessionContextGroup(sessionContextGroupId)}\n\t *\n\t *\n\t * **Intents API**\n\t *  * {@link InteropClient#fireIntent fireIntent(intent)}\n\t *  * {@link InteropClient#registerIntentHandler registerIntentHandler(intentHandler, intentName)}\n\t *  * {@link InteropClient#getInfoForIntent getInfoForIntent(infoForIntentOptions)}\n\t *  * {@link InteropClient#getInfoForIntentsByContext getInfoForIntentsByContext(context)}\n\t *  * {@link InteropClient#fireIntentForContext fireIntentForContext(contextForIntent)}\n\t *\n\t * ##### Interop methods intended for Windows\n\t *  * {@link InteropClient#getContextGroups getContextGroups()}\n\t *  * {@link InteropClient#joinContextGroup joinContextGroup(contextGroupId, target?)}\n\t *  * {@link InteropClient#removeFromContextGroup removeFromContextGroup(target?)}\n\t *  * {@link InteropClient#getInfoForContextGroup getInfoForContextGroup(contextGroupId)}\n\t *  * {@link InteropClient#getAllClientsInContextGroup getAllClientsInContextGroup(contextGroupId)}\n\t *\n\t */\n\tlet InteropClient$1 = class InteropClient extends base_1.Base {\n\t    /**\n\t     * @internal\n\t     */\n\t    constructor(wire, clientPromise) {\n\t        super(wire);\n\t        _InteropClient_clientPromise.set(this, void 0);\n\t        _InteropClient_sessionContextGroups.set(this, void 0);\n\t        __classPrivateFieldSet(this, _InteropClient_sessionContextGroups, new Map(), \"f\");\n\t        __classPrivateFieldSet(this, _InteropClient_clientPromise, clientPromise, \"f\");\n\t    }\n\t    /*\n\t    Client APIs\n\t    */\n\t    /**\n\t     * Sets a context for the context group of the current entity.\n\t     *\n\t     * @remarks The entity must be part of a context group in order set a context.\n\t     *\n\t     * @param context - New context to set.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * setInstrumentContext = async (ticker) => {\n\t     *     fin.me.interop.setContext({type: 'instrument', id: {ticker}})\n\t     * }\n\t     *\n\t     * // The user clicks an instrument of interest. We want to set that Instrument context so that the rest of our workflow updates with information for that instrument\n\t     * instrumentElement.on('click', (evt) => {\n\t     *     setInstrumentContext(evt.ticker)\n\t     * })\n\t     * ```\n\t     */\n\t    async setContext(context) {\n\t        this.wire.sendAction('interop-client-set-context').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        return client.dispatch('setContext', { context });\n\t    }\n\t    /**\n\t     * Add a context handler for incoming context. If an entity is part of a context group, and then sets its context handler,\n\t     * it will receive all of its declared contexts.\n\t     *\n\t     * @param handler - Handler for incoming context.\n\t     * @param contextType - The type of context you wish to handle.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * function handleIncomingContext(contextInfo) {\n\t     *     const { type, id } = contextInfo;\n\t     *     switch (type) {\n\t     *         case 'instrument':\n\t     *             handleInstrumentContext(contextInfo);\n\t     *             break;\n\t     *         case 'country':\n\t     *             handleCountryContext(contextInfo);\n\t     *             break;\n\t     *\n\t     *         default:\n\t     *             break;\n\t     *     }\n\t     * }\n\t     *\n\t     *\n\t     * function handleInstrumentContext(contextInfo) {\n\t     *     const { type, id } = contextInfo;\n\t     *     console.log('contextInfo for instrument', contextInfo)\n\t     * }\n\t     *\n\t     * function handleCountryContext(contextInfo) {\n\t     *     const { type, id } = contextInfo;\n\t     *     console.log('contextInfo for country', contextInfo)\n\t     * }\n\t     *\n\t     * fin.me.interop.addContextHandler(handleIncomingContext);\n\t     * ```\n\t     *\n\t     *\n\t     * Passing in a context type as the second parameter will cause the handler to only be invoked with that context type.\n\t     *\n\t     * ```js\n\t     * function handleInstrumentContext(contextInfo) {\n\t     *     const { type, id } = contextInfo;\n\t     *     console.log('contextInfo for instrument', contextInfo)\n\t     * }\n\t     *\n\t     * function handleCountryContext(contextInfo) {\n\t     *     const { type, id } = contextInfo;\n\t     *     console.log('contextInfo for country', contextInfo)\n\t     * }\n\t     *\n\t     *\n\t     * fin.me.interop.addContextHandler(handleInstrumentContext, 'instrument')\n\t     * fin.me.interop.addContextHandler(handleCountryContext, 'country')\n\t     * ```\n\t     */\n\t    async addContextHandler(handler, contextType) {\n\t        this.wire.sendAction('interop-client-add-context-handler').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        if (typeof handler !== 'function') {\n\t            throw new Error(\"Non-function argument passed to the first parameter 'handler'. Be aware that the argument order does not match the FDC3 standard.\");\n\t        }\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        let handlerId;\n\t        if (contextType) {\n\t            handlerId = `invokeContextHandler-${contextType}-${(0, utils_1.generateId)()}`;\n\t        }\n\t        else {\n\t            handlerId = 'invokeContextHandler';\n\t        }\n\t        const wrappedHandler = (0, utils_1.wrapContextHandler)(handler, handlerId);\n\t        client.register(handlerId, wrappedHandler);\n\t        await client.dispatch('contextHandlerRegistered', { handlerId, contextType });\n\t        return {\n\t            unsubscribe: async () => {\n\t                client.remove(handlerId);\n\t                await client.dispatch('removeContextHandler', { handlerId });\n\t            }\n\t        };\n\t    }\n\t    /*\n\t    Platform Window APIs\n\t    */\n\t    /**\n\t     * Returns the Interop-Broker-defined context groups available for an entity to join.\n\t     * Used by Platform Windows.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.me.interop.getContextGroups()\n\t     *         .then(contextGroups => {\n\t     *             contextGroups.forEach(contextGroup => {\n\t     *                 console.log(contextGroup.displayMetadata.name)\n\t     *                 console.log(contextGroup.displayMetadata.color)\n\t     *             })\n\t     *         })\n\t     * ```\n\t     */\n\t    async getContextGroups() {\n\t        this.wire.sendAction('interop-client-get-context-groups').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        return client.dispatch('getContextGroups');\n\t    }\n\t    /**\n\t     * Join all Interop Clients at the given identity to context group `contextGroupId`.\n\t     * If no target is specified, it adds the sender to the context group.\n\t     *\n\t     * @remarks Because multiple Channel connections/Interop Clients can potentially exist at a `uuid`/`name` combo, we currently join all Channel connections/Interop Clients at the given identity to the context group.\n\t     * If an `endpointId` is provided (which is unlikely, unless the call is coming from an external adapter), then we only join that single connection to the context group.\n\t     * For all intents and purposes, there will only be 1 connection present in Platform and Browser implmentations, so this point is more-or-less moot.\n\t     * Used by Platform Windows.\n\t     *\n\t     * @param contextGroupId - Id of the context group.\n\t     * @param target - Identity of the entity you wish to join to a context group.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * joinViewToContextGroup = async (contextGroupId, view) => {\n\t     *     await fin.me.interop.joinContextGroup(contextGroupId, view);\n\t     * }\n\t     *\n\t     * getLastFocusedView()\n\t     *     .then(lastFocusedViewIdentity => {\n\t     *         joinViewToContextGroup('red', lastFocusedViewIdentity)\n\t     *     })\n\t     * ```\n\t     */\n\t    async joinContextGroup(contextGroupId, target) {\n\t        this.wire.sendAction('interop-client-join-context-group').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        if (!contextGroupId) {\n\t            throw new Error('No contextGroupId specified for joinContextGroup.');\n\t        }\n\t        return client.dispatch('joinContextGroup', { contextGroupId, target });\n\t    }\n\t    /**\n\t     * Removes the specified target from a context group.\n\t     * If no target is specified, it removes the sender from their context group.\n\t     * Used by Platform Windows.\n\t     *\n\t     * @param target - Identity of the entity you wish to join to a context group.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * removeViewFromContextGroup = async (view) => {\n\t     *     await fin.me.interop.removeFromContextGroup(view);\n\t     * }\n\t     *\n\t     * getLastFocusedView()\n\t     *     .then(lastFocusedViewIdentity => {\n\t     *         removeViewFromContextGroup(lastFocusedViewIdentity)\n\t     *     })\n\t     * ```\n\t     */\n\t    async removeFromContextGroup(target) {\n\t        this.wire.sendAction('interop-client-remove-from-context-group').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        return client.dispatch('removeFromContextGroup', { target });\n\t    }\n\t    /**\n\t     * Gets all clients for a context group.\n\t     *\n\t     * @remarks **This is primarily used for platform windows. Views within a platform should not have to use this API.**\n\t     *\n\t     * Returns the Interop-Broker-defined context groups available for an entity to join.\n\t     * @param contextGroupId - The id of context group you wish to get clients for.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.me.interop.getAllClientsInContextGroup('red')\n\t     *     .then(clientsInContextGroup => {\n\t     *         console.log(clientsInContextGroup)\n\t     *     })\n\t     * ```\n\t     */\n\t    async getAllClientsInContextGroup(contextGroupId) {\n\t        this.wire.sendAction('interop-client-get-all-clients-in-context-group').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        if (!contextGroupId) {\n\t            throw new Error('No contextGroupId specified for getAllClientsInContextGroup.');\n\t        }\n\t        return client.dispatch('getAllClientsInContextGroup', { contextGroupId });\n\t    }\n\t    /**\n\t     * Gets display info for a context group\n\t     *\n\t     * @remarks Used by Platform Windows.\n\t     * @param contextGroupId - The id of context group you wish to get display info for.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * fin.me.interop.getInfoForContextGroup('red')\n\t     *     .then(contextGroupInfo => {\n\t     *         console.log(contextGroupInfo.displayMetadata.name)\n\t     *         console.log(contextGroupInfo.displayMetadata.color)\n\t     *     })\n\t     * ```\n\t     */\n\t    async getInfoForContextGroup(contextGroupId) {\n\t        this.wire.sendAction('interop-client-get-info-for-context-group').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        if (!contextGroupId) {\n\t            throw new Error('No contextGroupId specified for getInfoForContextGroup.');\n\t        }\n\t        return client.dispatch('getInfoForContextGroup', { contextGroupId });\n\t    }\n\t    /**\n\t     * Sends an intent to the Interop Broker to resolve.\n\t     * @param intent - The combination of an action and a context that is passed to an application for resolution.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * // View wants to fire an Intent after a user clicks on a ticker\n\t     * tickerElement.on('click', (element) => {\n\t     *     const ticker = element.innerText;\n\t     *     const intent = {\n\t     *         name: 'ViewChart',\n\t     *         context: {type: 'fdc3.instrument', id: { ticker }}\n\t     *     }\n\t     *\n\t     *     fin.me.interop.fireIntent(intent);\n\t     * })\n\t     * ```\n\t     */\n\t    async fireIntent(intent) {\n\t        this.wire.sendAction('interop-client-fire-intent').catch((e) => {\n\t            // don't expose, this is only for api analytics purposes\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        return client.dispatch('fireIntent', intent);\n\t    }\n\t    /**\n\t     * Adds an intent handler for incoming intents. The last intent sent of the name subscribed to will be received.\n\t     * @param handler - Registered function meant to handle a specific intent type.\n\t     * @param intentName - The name of an intent.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * const intentHandler = (intent) => {\n\t     *     const { context } = intent;\n\t     *     myViewChartHandler(context);\n\t     * };\n\t     *\n\t     * const subscription = await fin.me.interop.registerIntentHandler(intentHandler, 'ViewChart');\n\t     *\n\t     * function myAppCloseSequence() {\n\t     *     // to unsubscribe the handler, simply call:\n\t     *     subscription.unsubscribe();\n\t     * }\n\t     * ```\n\t     */\n\t    async registerIntentHandler(handler, intentName, options) {\n\t        this.wire.sendAction('interop-client-register-intent-handler').catch((e) => {\n\t            // don't expose, this is only for api analytics purposes\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        const handlerId = `intent-handler-${intentName}`;\n\t        const wrappedHandler = (0, utils_1.wrapIntentHandler)(handler, handlerId);\n\t        try {\n\t            await client.register(handlerId, wrappedHandler);\n\t            await client.dispatch('intentHandlerRegistered', { handlerId, ...options });\n\t        }\n\t        catch (error) {\n\t            throw new Error('Unable to register intent handler');\n\t        }\n\t        return {\n\t            unsubscribe: async () => {\n\t                client.remove(handlerId);\n\t            }\n\t        };\n\t    }\n\t    /**\n\t     * Gets the last context of the Context Group currently subscribed to. It takes an optional Context Type and returns the\n\t     * last context of that type.\n\t     * @param contextType\n\t     *\n\t     * @example\n\t     * ```js\n\t     * await fin.me.interop.joinContextGroup('yellow');\n\t     * await fin.me.interop.setContext({ type: 'instrument', id: { ticker: 'FOO' }});\n\t     * const currentContext = await fin.me.interop.getCurrentContext();\n\t     *\n\t     * // with a specific context\n\t     * await fin.me.interop.joinContextGroup('yellow');\n\t     * await fin.me.interop.setContext({ type: 'country', id: { ISOALPHA3: 'US' }});\n\t     * await fin.me.interop.setContext({ type: 'instrument', id: { ticker: 'FOO' }});\n\t     * const currentContext = await fin.me.interop.getCurrentContext('country');\n\t     * ```\n\t     */\n\t    async getCurrentContext(contextType) {\n\t        this.wire.sendAction('interop-client-get-current-context').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        return client.dispatch('getCurrentContext', { contextType });\n\t    }\n\t    /**\n\t     * Get information for a particular Intent from the Interop Broker.\n\t     *\n\t     * @remarks To resolve this info, the function handleInfoForIntent is meant to be overridden in the Interop Broker.\n\t     * The format for the response will be determined by the App Provider overriding the function.\n\t     *\n\t     * @param options\n\t     *\n\t     * @example\n\t     * ```js\n\t     * const intentInfo = await fin.me.interop.getInfoForIntent('ViewChart');\n\t     * ```\n\t     */\n\t    async getInfoForIntent(options) {\n\t        this.wire.sendAction('interop-client-get-info-for-intent').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        return client.dispatch('getInfoForIntent', options);\n\t    }\n\t    /**\n\t     * Get information from the Interop Broker on all Intents that are meant to handle a particular context.\n\t     *\n\t     * @remarks To resolve this info, the function handleInfoForIntentsByContext is meant to be overridden in the Interop Broker.\n\t     * The format for the response will be determined by the App Provider overriding the function.\n\t     *\n\t     * @param context\n\t     *\n\t     * @example\n\t     * ```js\n\t     * tickerElement.on('click', (element) => {\n\t     *     const ticker = element.innerText;\n\t     *\n\t     *     const context = {\n\t     *         type: 'fdc3.instrument',\n\t     *         id: {\n\t     *             ticker\n\t     *         }\n\t     *     }\n\t     *\n\t     *     const intentsInfo = await fin.me.interop.getInfoForIntentByContext(context);\n\t     * })\n\t     * ```\n\t     */\n\t    async getInfoForIntentsByContext(context) {\n\t        this.wire.sendAction('interop-client-get-info-for-intents-by-context').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        return client.dispatch('getInfoForIntentsByContext', context);\n\t    }\n\t    /**\n\t     * Sends a Context that will be resolved to an Intent by the Interop Broker.\n\t     * This context accepts a metadata property.\n\t     *\n\t     * @remarks To resolve this info, the function handleFiredIntentByContext is meant to be overridden in the Interop Broker.\n\t     * The format for the response will be determined by the App Provider overriding the function.\n\t     *\n\t     * @param context\n\t     *\n\t     * @example\n\t     * ```js\n\t     * tickerElement.on('click', (element) => {\n\t     *     const ticker = element.innerText;\n\t     *\n\t     *     const context = {\n\t     *         type: 'fdc3.instrument',\n\t     *         id: {\n\t     *             ticker\n\t     *         }\n\t     *     }\n\t     *\n\t     *     const intentResolution = await fin.me.interop.fireIntentForContext(context);\n\t     * })\n\t     * ```\n\t     */\n\t    async fireIntentForContext(context) {\n\t        this.wire.sendAction('interop-client-fire-intent-for-context').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        return client.dispatch('fireIntentForContext', context);\n\t    }\n\t    /**\n\t     * Join the current entity to session context group `sessionContextGroupId` and return a sessionContextGroup instance.\n\t     * If the sessionContextGroup doesn't exist, one will get created.\n\t     *\n\t     * @remarks Session Context Groups do not persist between runs and aren't present on snapshots.\n\t     * @param sessionContextGroupId - Id of the context group.\n\t     *\n\t     * @example\n\t     * Say we want to have a Session Context Group that holds UI theme information for all apps to consume:\n\t     *\n\t     * My color-picker View:\n\t     * ```js\n\t     *     const themeSessionContextGroup = await fin.me.interop.joinSessionContextGroup('theme');\n\t     *\n\t     *     const myColorPickerElement = document.getElementById('color-palette-picker');\n\t     *     myColorPickerElement.addEventListener('change', event => {\n\t     *         themeSessionContextGroup.setContext({ type: 'color-palette', selection: event.value });\n\t     *     });\n\t     * ```\n\t     *\n\t     * In other views:\n\t     * ```js\n\t     *     const themeSessionContextGroup = await fin.me.interop.joinSessionContextGroup('theme');\n\t     *\n\t     *     const changeColorPalette = ({ selection }) => {\n\t     *         // change the color palette to the selection\n\t     *     };\n\t     *\n\t     *     // If the context is already set by the time the handler was set, the handler will get invoked immediately with the current context.\n\t     *     themeSessionContextGroup.addContextHandler(changeColorPalette, 'color-palette');\n\t     * ```\n\t     */\n\t    async joinSessionContextGroup(sessionContextGroupId) {\n\t        try {\n\t            const currentSessionContextGroup = __classPrivateFieldGet(this, _InteropClient_sessionContextGroups, \"f\").get(sessionContextGroupId);\n\t            if (currentSessionContextGroup) {\n\t                return currentSessionContextGroup.getUserInstance();\n\t            }\n\t            const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t            const { hasConflict } = await client.dispatch('sessionContextGroup:createIfNeeded', {\n\t                sessionContextGroupId\n\t            });\n\t            if (hasConflict) {\n\t                console.warn(`A (non-session) context group with the name \"${sessionContextGroupId}\" already exists. If you are trying to join a Context Group, call joinContextGroup instead.`);\n\t            }\n\t            const newSessionContextGroup = new SessionContextGroupClient_1.default(this.wire, __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\"), sessionContextGroupId);\n\t            __classPrivateFieldGet(this, _InteropClient_sessionContextGroups, \"f\").set(sessionContextGroupId, newSessionContextGroup);\n\t            return newSessionContextGroup.getUserInstance();\n\t        }\n\t        catch (error) {\n\t            console.error(`Error thrown trying to create Session Context Group with id \"${sessionContextGroupId}\": ${error}`);\n\t            throw error;\n\t        }\n\t    }\n\t    /**\n\t     * Register a listener that is called when the Interop Client has been disconnected from the Interop Broker.\n\t     * Only one listener per Interop Client can be set.\n\t     * @param listener\n\t     *\n\t     * @example\n\t     * ```js\n\t     * const listener = (event) => {\n\t     *     const { type, topic, brokerName} = event;\n\t     *     console.log(`Disconnected from Interop Broker ${brokerName} `);\n\t     * }\n\t     *\n\t     * await fin.me.interop.onDisconnection(listener);\n\t     * ```\n\t     */\n\t    async onDisconnection(listener) {\n\t        this.wire.sendAction('interop-client-add-ondisconnection-listener').catch((e) => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, \"f\");\n\t        return client.onDisconnection((event) => {\n\t            const { uuid } = event;\n\t            listener({ type: 'interop-broker', topic: 'disconnected', brokerName: uuid });\n\t        });\n\t    }\n\t    getFDC3Sync(version) {\n\t        switch (version) {\n\t            case '1.2':\n\t                return new fdc3_1_2_1.Fdc3Module(() => this, this.wire);\n\t            case '2.0':\n\t                return new fdc3_2_0_1.Fdc3Module2(() => this, this.wire);\n\t            default:\n\t                throw new Error(`Invalid FDC3 version provided: ${version}. Must be '1.2' or '2.0'`);\n\t        }\n\t    }\n\t    async getFDC3(version) {\n\t        return this.getFDC3Sync(version);\n\t    }\n\t    /**\n\t     * @internal\n\t     *\n\t     * Used to ferry fdc3-only calls from the fdc3 shim to the Interop Broker\n\t     */\n\t    static async ferryFdc3Call(interopClient, action, payload) {\n\t        const client = await __classPrivateFieldGet(interopClient, _InteropClient_clientPromise, \"f\");\n\t        return client.dispatch(action, payload || null);\n\t    }\n\t};\n\tInteropClient.InteropClient = InteropClient$1;\n\t_InteropClient_clientPromise = new WeakMap(), _InteropClient_sessionContextGroups = new WeakMap();\n\treturn InteropClient;\n}\n\nvar overrideCheck = {};\n\nvar hasRequiredOverrideCheck;\n\nfunction requireOverrideCheck () {\n\tif (hasRequiredOverrideCheck) return overrideCheck;\n\thasRequiredOverrideCheck = 1;\n\tObject.defineProperty(overrideCheck, \"__esModule\", { value: true });\n\toverrideCheck.overrideCheck = overrideCheck.checkFDC32Overrides = overrideCheck.getDefaultViewFdc3VersionFromAppInfo = void 0;\n\tconst InteropBroker_1 = requireInteropBroker();\n\tfunction getDefaultViewFdc3VersionFromAppInfo({ manifest, initialOptions }) {\n\t    const setVersion = manifest?.platform?.defaultViewOptions?.fdc3InteropApi ?? initialOptions.defaultViewOptions?.fdc3InteropApi;\n\t    return ['1.2', '2.0'].includes(setVersion ?? '') ? setVersion : undefined;\n\t}\n\toverrideCheck.getDefaultViewFdc3VersionFromAppInfo = getDefaultViewFdc3VersionFromAppInfo;\n\tfunction checkFDC32Overrides(overriddenBroker) {\n\t    // These are the APIs that must be overridden for FDC3 2.0 compliance\n\t    const mustOverrideAPIs = [\n\t        'fdc3HandleFindInstances',\n\t        'handleInfoForIntent',\n\t        'handleInfoForIntentsByContext',\n\t        'fdc3HandleGetAppMetadata',\n\t        'fdc3HandleGetInfo',\n\t        'fdc3HandleOpen',\n\t        'handleFiredIntent',\n\t        'handleFiredIntentForContext'\n\t    ];\n\t    return mustOverrideAPIs.filter((api) => {\n\t        return overriddenBroker[api] === InteropBroker_1.InteropBroker.prototype[api];\n\t    });\n\t}\n\toverrideCheck.checkFDC32Overrides = checkFDC32Overrides;\n\tfunction overrideCheck$1(overriddenBroker, fdc3InteropApi) {\n\t    if (fdc3InteropApi && fdc3InteropApi === '2.0') {\n\t        const notOverridden = checkFDC32Overrides(overriddenBroker);\n\t        if (notOverridden.length > 0) {\n\t            console.warn(`WARNING: FDC3 2.0 has been set as a default option for Views in this Platform, but the required InteropBroker APIs for FDC3 2.0 compliance have not all been overridden.\\nThe following APIs need to be overridden:\\n${notOverridden.join('\\n')}`);\n\t        }\n\t    }\n\t}\n\toverrideCheck.overrideCheck = overrideCheck$1;\n\treturn overrideCheck;\n}\n\nvar hasRequiredFactory;\n\nfunction requireFactory () {\n\tif (hasRequiredFactory) return Factory$1;\n\thasRequiredFactory = 1;\n\tvar __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {\n\t    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n\t};\n\tObject.defineProperty(Factory$1, \"__esModule\", { value: true });\n\tFactory$1.InteropModule = void 0;\n\tconst cloneDeep_1 = __importDefault(require$$0$1);\n\tconst inaccessibleObject_1 = inaccessibleObject;\n\tconst base_1 = base;\n\tconst InteropBroker_1 = requireInteropBroker();\n\tconst InteropClient_1 = requireInteropClient();\n\tconst overrideCheck_1 = requireOverrideCheck();\n\tconst common_utils_1 = commonUtils;\n\tconst defaultOverride = (Class) => new Class();\n\tconst BrokerParamAccessError = 'You have attempted to use or modify InteropBroker parameters, which is not allowed. You are likely using an older InteropBroker override scheme. Please consult our Interop docs for guidance on migrating to the new override scheme.';\n\t/**\n\t * Manages creation of Interop Brokers and Interop Clients. These APIs are called under-the-hood in Platforms.\n\t *\n\t */\n\tclass InteropModule extends base_1.Base {\n\t    /**\n\t     * Initializes an Interop Broker. This is called under-the-hood for Platforms.\n\t     *\n\t     * @remarks For Platforms, this is set up automatically. We advise to only create your own Interop Broker\n\t     * when not using a Platform app. You can override functions in the Interop Broker. More info {@link InteropBroker here}.\n\t     *\n\t     * @param name - Name of the Interop Broker.\n\t     * @param override - A callback function or array of callback functions that can be used to extend or replace default Interop Broker behavior.\n\t     *\n\t     * @example\n\t     * ``` js\n\t     * const interopBroker = await fin.Interop.init('openfin');\n\t     * const contextGroups = await interopBroker.getContextGroups();\n\t     * console.log(contextGroups);\n\t     * ```\n\t     */\n\t    async init(name, override = defaultOverride) {\n\t        this.wire.sendAction('interop-init').catch(() => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        // Allows for manifest-level configuration, without having to override. (e.g. specifying custom context groups)\n\t        const options = await this.wire.environment.getInteropInfo(this.wire.getFin());\n\t        const objectThatThrows = (0, inaccessibleObject_1.createUnusableObject)(BrokerParamAccessError);\n\t        const warningOptsClone = (0, inaccessibleObject_1.createWarningObject)(BrokerParamAccessError, (0, cloneDeep_1.default)(options));\n\t        const getProvider = () => {\n\t            return this.fin.InterApplicationBus.Channel.create(`interop-broker-${name}`);\n\t        };\n\t        const throwingGetProvider = async () => {\n\t            // eslint-disable-next-line no-console\n\t            throw new Error(BrokerParamAccessError);\n\t        };\n\t        const OverrideableBroker = InteropBroker_1.InteropBroker.createClosedConstructor(this.wire, getProvider, options);\n\t        let broker;\n\t        if (Array.isArray(override)) {\n\t            const BrokerConstructor = (0, common_utils_1.overrideFromComposables)(...override)(OverrideableBroker);\n\t            // We need to use these objects because removing them entirely would be a breaking change and we want an informative error\n\t            // @ts-expect-error\n\t            broker = new BrokerConstructor(objectThatThrows, throwingGetProvider, warningOptsClone);\n\t        }\n\t        else {\n\t            // We need to use these objects because removing them entirely would be a breaking change and we want an informative error\n\t            // @ts-expect-error\n\t            broker = await override(OverrideableBroker, objectThatThrows, throwingGetProvider, warningOptsClone);\n\t        }\n\t        (0, overrideCheck_1.overrideCheck)(broker, options.fdc3Version);\n\t        return broker;\n\t    }\n\t    /**\n\t     * Connects a client to an Interop broker. This is called under-the-hood for Views in a Platform.\n\t     *\n\t     * @remarks\n\t     * @param name - The name of the Interop Broker to connect to. For Platforms, this will default to the uuid of the Platform.\n\t     * @param interopConfig - Information relevant to the Interop Broker. Typically a declaration of\n\t     * what context(s) the entity wants to subscribe to, and the current Context Group of the entity.\n\t     *\n\t     * @example\n\t     * ```js\n\t     * const interopConfig = {\n\t     *     currentContextGroup: 'green'\n\t     * }\n\t     *\n\t     * const interopBroker = await fin.Interop.init('openfin');\n\t     * const client = await fin.Interop.connectSync('openfin', interopConfig);\n\t     * const contextGroupInfo = await client.getInfoForContextGroup();\n\t     * console.log(contextGroupInfo);\n\t     * ```\n\t     */\n\t    connectSync(name, interopConfig) {\n\t        this.wire.sendAction('interop-connect-sync').catch(() => {\n\t            // don't expose, analytics-only call\n\t        });\n\t        return new InteropClient_1.InteropClient(this.wire, this.wire.environment.whenReady().then(() => {\n\t            return this.fin.InterApplicationBus.Channel.connect(`interop-broker-${name}`, {\n\t                payload: interopConfig\n\t            });\n\t        }));\n\t    }\n\t}\n\tFactory$1.InteropModule = InteropModule;\n\treturn Factory$1;\n}\n\nvar hasRequiredInterop;\n\nfunction requireInterop () {\n\tif (hasRequiredInterop) return interop;\n\thasRequiredInterop = 1;\n\t(function (exports) {\n\t\t/**\n\t\t * Entry point for the OpenFin `Interop` API (`fin.Interop`).\n\t\t *\n\t\t * * {@link InteropModule} contains static members of the `Interop` API (available under `fin.Interop`)\n\t\t * * {@link InteropClient} and {@link InteropBroker} document instances of their respective classes.\n\t\t *\n\t\t * @packageDocumentation\n\t\t */\n\t\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t\t    if (k2 === undefined) k2 = k;\n\t\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t\t    }\n\t\t    Object.defineProperty(o, k2, desc);\n\t\t}) : (function(o, m, k, k2) {\n\t\t    if (k2 === undefined) k2 = k;\n\t\t    o[k2] = m[k];\n\t\t}));\n\t\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t\t};\n\t\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t\t__exportStar(requireFactory(), exports);\n\t\t__exportStar(requireInteropClient(), exports);\n\t\t__exportStar(requireInteropBroker(), exports); \n\t} (interop));\n\treturn interop;\n}\n\nvar snapshotSource = {};\n\nvar Factory = {};\n\nvar Instance = {};\n\nvar utils = {};\n\nObject.defineProperty(utils, \"__esModule\", { value: true });\nutils.getSnapshotSourceChannelName = void 0;\nconst channelPrefix = 'snapshot-source-provider-';\nconst getSnapshotSourceChannelName = (id) => `${channelPrefix}${id.uuid}`;\nutils.getSnapshotSourceChannelName = getSnapshotSourceChannelName;\n\nvar __classPrivateFieldSet$1 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar __classPrivateFieldGet$1 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar _SnapshotSource_identity, _SnapshotSource_getConnection, _SnapshotSource_getClient, _SnapshotSource_startConnection, _SnapshotSource_setUpConnectionListener;\nObject.defineProperty(Instance, \"__esModule\", { value: true });\nInstance.SnapshotSource = void 0;\n/* eslint-disable @typescript-eslint/no-non-null-assertion */\nconst base_1$1 = base;\nconst utils_1$1 = utils;\nconst connectionMap = new Map();\n/**\n * Enables configuring a SnapshotSource with custom getSnapshot and applySnapshot methods.\n *\n * @typeParam Snapshot Implementation-defined shape of an application snapshot.  Allows\n * custom snapshot implementations for legacy applications to define their own snapshot format.\n */\nclass SnapshotSource extends base_1$1.Base {\n    /**\n     * @internal\n     */\n    constructor(wire, id) {\n        super(wire);\n        _SnapshotSource_identity.set(this, void 0);\n        _SnapshotSource_getConnection.set(this, () => {\n            if (!connectionMap.has(this.identity.uuid)) {\n                connectionMap.set(this.identity.uuid, { eventFired: null, clientPromise: null });\n            }\n            return connectionMap.get(this.identity.uuid);\n        });\n        _SnapshotSource_getClient.set(this, () => {\n            if (!__classPrivateFieldGet$1(this, _SnapshotSource_getConnection, \"f\").call(this).clientPromise) {\n                __classPrivateFieldGet$1(this, _SnapshotSource_getConnection, \"f\").call(this).clientPromise = __classPrivateFieldGet$1(this, _SnapshotSource_startConnection, \"f\").call(this);\n            }\n            return __classPrivateFieldGet$1(this, _SnapshotSource_getConnection, \"f\").call(this).clientPromise;\n        });\n        _SnapshotSource_startConnection.set(this, async () => {\n            const channelName = (0, utils_1$1.getSnapshotSourceChannelName)(this.identity);\n            try {\n                if (!__classPrivateFieldGet$1(this, _SnapshotSource_getConnection, \"f\").call(this).eventFired) {\n                    await __classPrivateFieldGet$1(this, _SnapshotSource_setUpConnectionListener, \"f\").call(this);\n                }\n                const client = await this.fin.InterApplicationBus.Channel.connect(channelName, { wait: false });\n                client.onDisconnection(() => {\n                    __classPrivateFieldGet$1(this, _SnapshotSource_getConnection, \"f\").call(this).clientPromise = null;\n                    __classPrivateFieldGet$1(this, _SnapshotSource_getConnection, \"f\").call(this).eventFired = null;\n                });\n                return client;\n            }\n            catch (e) {\n                __classPrivateFieldGet$1(this, _SnapshotSource_getConnection, \"f\").call(this).clientPromise = null;\n                throw new Error(\"The targeted SnapshotSource is not currently initialized. Await this object's ready() method.\");\n            }\n        });\n        _SnapshotSource_setUpConnectionListener.set(this, async () => {\n            const channelName = (0, utils_1$1.getSnapshotSourceChannelName)(this.identity);\n            let resolve;\n            let reject;\n            const eventFired = new Promise((y, n) => {\n                resolve = y;\n                reject = n;\n            });\n            __classPrivateFieldGet$1(this, _SnapshotSource_getConnection, \"f\").call(this).eventFired = eventFired;\n            const listener = async (e) => {\n                try {\n                    if (e.channelName === channelName) {\n                        resolve();\n                        await this.fin.InterApplicationBus.Channel.removeListener('connected', listener);\n                    }\n                }\n                catch (err) {\n                    reject(err);\n                }\n            };\n            await this.fin.InterApplicationBus.Channel.on('connected', listener);\n        });\n        __classPrivateFieldSet$1(this, _SnapshotSource_identity, id, \"f\");\n    }\n    get identity() {\n        return __classPrivateFieldGet$1(this, _SnapshotSource_identity, \"f\");\n    }\n    /**\n     * Method to determine if the SnapshotSource has been initialized.\n     *\n     * @remarks Use when the parent application is starting up to ensure the SnapshotSource is able to accept and\n     * apply a snapshot using the {@link SnapshotSource#applySnapshot applySnapshot} method.\n     *\n     * @example\n     * ```js\n     * let snapshotSource = fin.SnapshotSource.wrapSync(fin.me);\n     *\n     * const snapshotProvider = {\n     *     async getSnapshot() { return 'foo' },\n     *     async applySnapshot(snapshot) {\n     *       console.log(snapshot);\n     *       return undefined;\n     *     }\n     * }\n     * await fin.SnapshotSource.init(snapshotProvider);\n     *\n     * try {\n     *   await snapshotSource.ready();\n     *   await snapshotSource.applySnapshot('foo');\n     * } catch (err) {\n     *   console.log(err)\n     * }\n     * ```\n     */\n    async ready() {\n        this.wire.sendAction('snapshot-source-ready').catch((e) => {\n            // don't expose, analytics-only call\n        });\n        // eslint-disable-next-line no-async-promise-executor\n        try {\n            // If getClient was already called before this, do we have a timing issue where the channel might have been created but we missed the event but this still fails?\n            await __classPrivateFieldGet$1(this, _SnapshotSource_getClient, \"f\").call(this);\n        }\n        catch (e) {\n            // it was not running.\n            await __classPrivateFieldGet$1(this, _SnapshotSource_getConnection, \"f\").call(this).eventFired;\n        }\n    }\n    /**\n     * Call the SnapshotSource's getSnapshot method defined by {@link SnapshotSource.SnapshotSourceModule#init init}.\n     *\n     */\n    async getSnapshot() {\n        this.wire.sendAction('snapshot-source-get-snapshot').catch((e) => {\n            // don't expose, analytics-only call\n        });\n        const client = await __classPrivateFieldGet$1(this, _SnapshotSource_getClient, \"f\").call(this);\n        const response = (await client.dispatch('get-snapshot'));\n        return (await response).snapshot;\n    }\n    /**\n     * Call the SnapshotSource's applySnapshot method defined by {@link SnapshotSource.SnapshotSourceModule#init init}.\n     *\n     */\n    async applySnapshot(snapshot) {\n        this.wire.sendAction('snapshot-source-apply-snapshot').catch((e) => {\n            // don't expose, analytics-only call\n        });\n        const client = await __classPrivateFieldGet$1(this, _SnapshotSource_getClient, \"f\").call(this);\n        return client.dispatch('apply-snapshot', { snapshot });\n    }\n}\nInstance.SnapshotSource = SnapshotSource;\n_SnapshotSource_identity = new WeakMap(), _SnapshotSource_getConnection = new WeakMap(), _SnapshotSource_getClient = new WeakMap(), _SnapshotSource_startConnection = new WeakMap(), _SnapshotSource_setUpConnectionListener = new WeakMap();\n\nObject.defineProperty(Factory, \"__esModule\", { value: true });\nFactory.SnapshotSourceModule = void 0;\nconst base_1 = base;\nconst Instance_1 = Instance;\nconst utils_1 = utils;\n/**\n * Static namespace for OpenFin API methods that interact with the {@link SnapshotSource} class, available under `fin.SnapshotSource`.\n */\nclass SnapshotSourceModule extends base_1.Base {\n    /**\n     * Initializes a SnapshotSource with the getSnapshot and applySnapshot methods defined.\n     *\n     * @typeParam Snapshot Implementation-defined shape of an application snapshot.  Allows\n     * custom snapshot implementations for legacy applications to define their own snapshot format.\n     *\n     * @example\n     * ```js\n     * const snapshotProvider = {\n     *     async getSnapshot() {\n     *       const bounds = await fin.me.getBounds();\n     *       return bounds;\n     *      },\n     *     async applySnapshot(snapshot) {\n     *       await fin.me.setBounds(snapshot);\n     *       return undefined;\n     *     }\n     * }\n     *\n     * await fin.SnapshotSource.init(snapshotProvider);\n     * ```\n     *\n     */\n    async init(provider) {\n        this.wire.sendAction('snapshot-source-init').catch((e) => {\n            // don't expose, analytics-only call\n        });\n        if (typeof provider !== 'object' ||\n            typeof provider.getSnapshot !== 'function' ||\n            typeof provider.applySnapshot !== 'function') {\n            throw new Error('you must pass in a valid SnapshotProvider');\n        }\n        const channel = await this.fin.InterApplicationBus.Channel.create((0, utils_1.getSnapshotSourceChannelName)(this.fin.me));\n        channel.register('get-snapshot', async () => {\n            const snapshot = await provider.getSnapshot();\n            return { snapshot };\n        });\n        channel.register('apply-snapshot', ({ snapshot }) => provider.applySnapshot(snapshot));\n    }\n    /**\n     * Synchronously returns a SnapshotSource object that represents the current SnapshotSource.\n     *\n     * @example\n     * ```js\n     * const snapshotSource = fin.SnapshotSource.wrapSync(fin.me);\n     * // Use wrapped instance's getSnapshot method, e.g.:\n     * const snapshot = await snapshotSource.getSnapshot();\n     * ```\n     */\n    wrapSync(identity) {\n        this.wire.sendAction('snapshot-source-wrap-sync').catch((e) => {\n            // don't expose, analytics-only call\n        });\n        return new Instance_1.SnapshotSource(this.wire, identity);\n    }\n    /**\n     * Asynchronously returns a SnapshotSource object that represents the current SnapshotSource.\n     *\n     * @example\n     * ```js\n     * const snapshotSource = await fin.SnapshotSource.wrap(fin.me);\n     * // Use wrapped instance's getSnapshot method, e.g.:\n     * const snapshot = await snapshotSource.getSnapshot();\n     * ```\n     */\n    async wrap(identity) {\n        this.wire.sendAction('snapshot-source-wrap').catch((e) => {\n            // don't expose, analytics-only call\n        });\n        return this.wrapSync(identity);\n    }\n}\nFactory.SnapshotSourceModule = SnapshotSourceModule;\n\n(function (exports) {\n\t/**\n\t * Entry points for the OpenFin `SnapshotSource` API (`fin.SnapshotSource`).\n\t *\n\t * * {@link SnapshotSourceModule} contains static members of the `SnapshotSource` API, accessible through `fin.SnapshotSource`.\n\t * * {@link SnapshotSource} describes an instance of an OpenFin SnapshotSource, e.g. as returned by `fin.SnapshotSource.wrap`.\n\t *\n\t * These are separate code entities, and are documented separately.  In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/32.114.76.10/index.html),\n\t * both of these were documented on the same page.\n\t *\n\t * @packageDocumentation\n\t */\n\tvar __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    var desc = Object.getOwnPropertyDescriptor(m, k);\n\t    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n\t      desc = { enumerable: true, get: function() { return m[k]; } };\n\t    }\n\t    Object.defineProperty(o, k2, desc);\n\t}) : (function(o, m, k, k2) {\n\t    if (k2 === undefined) k2 = k;\n\t    o[k2] = m[k];\n\t}));\n\tvar __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {\n\t    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n\t};\n\tObject.defineProperty(exports, \"__esModule\", { value: true });\n\t__exportStar(Factory, exports);\n\t__exportStar(Instance, exports); \n} (snapshotSource));\n\nObject.defineProperty(fin$2, \"__esModule\", { value: true });\nvar Fin_1 = fin$2.Fin = void 0;\nconst events_1$3 = require$$0;\n// Import from the file rather than the directory in case someone consuming types is using module resolution other than \"node\"\nconst index_1 = system;\nconst index_2 = requireWindow();\nconst index_3 = requireApplication();\nconst index_4 = interappbus;\nconst index_5 = clipboard;\nconst index_6 = externalApplication;\nconst index_7 = frame;\nconst index_8 = globalHotkey;\nconst index_9 = requireView();\nconst index_10 = platform;\nconst me_1$2 = me;\nconst interop_1 = requireInterop();\nconst snapshot_source_1 = snapshotSource;\n/**\n * @internal\n */\nclass Fin extends events_1$3.EventEmitter {\n    /**\n     * @internal\n     */\n    constructor(wire) {\n        super();\n        this.wire = wire;\n        this.System = new index_1.System(wire);\n        this.Window = new index_2._WindowModule(wire);\n        this.Application = new index_3.ApplicationModule(wire);\n        this.InterApplicationBus = new index_4.InterApplicationBus(wire);\n        this.Clipboard = new index_5.Clipboard(wire);\n        this.ExternalApplication = new index_6.ExternalApplicationModule(wire);\n        this.Frame = new index_7._FrameModule(wire);\n        this.GlobalHotkey = new index_8.GlobalHotkey(wire);\n        this.Platform = new index_10.PlatformModule(wire, this.InterApplicationBus.Channel);\n        this.View = new index_9.ViewModule(wire);\n        this.Interop = new interop_1.InteropModule(wire);\n        this.SnapshotSource = new snapshot_source_1.SnapshotSourceModule(wire);\n        wire.registerFin(this);\n        this.me = (0, me_1$2.getMe)(wire);\n        // Handle disconnect events\n        wire.on('disconnected', () => {\n            this.emit('disconnected');\n        });\n    }\n}\nFin_1 = fin$2.Fin = Fin;\n\nvar transport = {};\n\nvar wire = {};\n\nObject.defineProperty(wire, \"__esModule\", { value: true });\nwire.isInternalConnectConfig = wire.isPortDiscoveryConfig = wire.isNewConnectConfig = wire.isConfigWithReceiver = wire.isRemoteConfig = wire.isExistingConnectConfig = wire.isExternalConfig = void 0;\nfunction isExternalConfig(config) {\n    if (typeof config.manifestUrl === 'string') {\n        return true;\n    }\n    return false;\n}\nwire.isExternalConfig = isExternalConfig;\nfunction isExistingConnectConfig(config) {\n    return hasUuid(config) && typeof config.address === 'string';\n}\nwire.isExistingConnectConfig = isExistingConnectConfig;\nfunction isRemoteConfig(config) {\n    return isExistingConnectConfig(config) && typeof config.token === 'string';\n}\nwire.isRemoteConfig = isRemoteConfig;\nfunction isConfigWithReceiver(config) {\n    return typeof config.receiver === 'object' && isRemoteConfig({ ...config, address: '' });\n}\nwire.isConfigWithReceiver = isConfigWithReceiver;\nfunction hasUuid(config) {\n    return typeof config.uuid === 'string';\n}\nfunction hasRuntimeVersion(config) {\n    return config.runtime && typeof config.runtime.version === 'string';\n}\nfunction isNewConnectConfig(config) {\n    return hasUuid(config) && hasRuntimeVersion(config);\n}\nwire.isNewConnectConfig = isNewConnectConfig;\nfunction isPortDiscoveryConfig(config) {\n    return (isExternalConfig(config) && hasRuntimeVersion(config)) || isNewConnectConfig(config);\n}\nwire.isPortDiscoveryConfig = isPortDiscoveryConfig;\nfunction isInternalConnectConfig(config) {\n    return isExistingConnectConfig(config) || isNewConnectConfig(config);\n}\nwire.isInternalConnectConfig = isInternalConnectConfig;\n\nvar eventAggregator = {};\n\nvar emitterMap = {};\n\nObject.defineProperty(emitterMap, \"__esModule\", { value: true });\nemitterMap.EmitterMap = void 0;\nconst events_1$2 = require$$0;\nclass EmitterMap {\n    constructor() {\n        this.storage = new Map();\n    }\n    // eslint-disable-next-line class-methods-use-this\n    hashKeys(keys) {\n        const hashed = keys.map(normalizeString);\n        return hashed.join('/');\n    }\n    getOrCreate(keys) {\n        const hash = this.hashKeys(keys);\n        if (!this.storage.has(hash)) {\n            this.storage.set(hash, new events_1$2.EventEmitter());\n        }\n        // We set it above\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        return this.storage.get(hash);\n    }\n    has(keys) {\n        return this.storage.has(this.hashKeys(keys));\n    }\n    delete(keys) {\n        const hash = this.hashKeys(keys);\n        return this.storage.delete(hash);\n    }\n}\nemitterMap.EmitterMap = EmitterMap;\nfunction normalizeString(s) {\n    const b = Buffer.from(s);\n    return b.toString('base64');\n}\n\nObject.defineProperty(eventAggregator, \"__esModule\", { value: true });\nconst emitterMap_1 = emitterMap;\nfunction isEventMessage(message) {\n    return message.action === 'process-desktop-event';\n}\nfunction mapKeyFromEvent(event) {\n    const { topic } = event;\n    if (topic === 'frame' || topic === 'window' || topic === 'view') {\n        const { uuid, name } = event;\n        return [topic, uuid, name];\n    }\n    if (topic === 'application') {\n        const { uuid } = event;\n        return [topic, uuid];\n    }\n    return [topic];\n}\nclass EventAggregator extends emitterMap_1.EmitterMap {\n    constructor() {\n        super(...arguments);\n        this.dispatchEvent = (message) => {\n            if (isEventMessage(message)) {\n                const { payload } = message;\n                const accessor = mapKeyFromEvent(payload);\n                if (this.has(accessor)) {\n                    this.getOrCreate(accessor).emit(payload.type, payload);\n                    return true;\n                }\n            }\n            return false;\n        };\n    }\n}\neventAggregator.default = EventAggregator;\n\nvar __classPrivateFieldSet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n};\nvar __classPrivateFieldGet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n};\nvar __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nvar _Transport_wire, _Transport_fin;\nObject.defineProperty(transport, \"__esModule\", { value: true });\nvar Transport_1 = transport.Transport = void 0;\nconst events_1$1 = require$$0;\nconst wire_1 = wire;\nconst transport_errors_1 = transportErrors;\nconst eventAggregator_1 = __importDefault(eventAggregator);\nconst me_1$1 = me;\nconst errors_1 = errors;\nclass Transport extends events_1$1.EventEmitter {\n    constructor(WireType, environment, config) {\n        super();\n        this.wireListeners = new Map();\n        this.topicRefMap = new Map();\n        this.eventAggregator = new eventAggregator_1.default();\n        this.messageHandlers = [this.eventAggregator.dispatchEvent];\n        _Transport_wire.set(this, void 0);\n        // Typing as unknown to avoid circular dependency, should not be used directly.\n        _Transport_fin.set(this, void 0);\n        this.connectSync = () => {\n            const wire = __classPrivateFieldGet(this, _Transport_wire, \"f\");\n            wire.connectSync();\n        };\n        // This function is only used in our tests.\n        this.getPort = () => {\n            const wire = __classPrivateFieldGet(this, _Transport_wire, \"f\");\n            return wire.getPort();\n        };\n        __classPrivateFieldSet(this, _Transport_wire, new WireType(this.onmessage.bind(this)), \"f\");\n        this.environment = environment;\n        this.sendRaw = __classPrivateFieldGet(this, _Transport_wire, \"f\").send.bind(__classPrivateFieldGet(this, _Transport_wire, \"f\"));\n        this.registerMessageHandler(this.handleMessage.bind(this));\n        __classPrivateFieldGet(this, _Transport_wire, \"f\").on('disconnected', () => {\n            for (const [, { handleNack }] of this.wireListeners) {\n                handleNack({ reason: 'Remote connection has closed' });\n            }\n            this.wireListeners.clear();\n            this.emit('disconnected');\n        });\n        const { uuid, name } = config;\n        const entityType = this.environment.getCurrentEntityType();\n        this.me = (0, me_1$1.getBaseMe)(entityType, uuid, name);\n    }\n    getFin() {\n        if (!__classPrivateFieldGet(this, _Transport_fin, \"f\")) {\n            throw new Error('No Fin object registered for this transport');\n        }\n        return __classPrivateFieldGet(this, _Transport_fin, \"f\");\n    }\n    registerFin(_fin) {\n        if (__classPrivateFieldGet(this, _Transport_fin, \"f\")) {\n            throw new Error('Fin object has already been registered for this transport');\n        }\n        __classPrivateFieldSet(this, _Transport_fin, _fin, \"f\");\n    }\n    shutdown() {\n        const wire = __classPrivateFieldGet(this, _Transport_wire, \"f\");\n        return wire.shutdown();\n    }\n    async connect(config) {\n        if ((0, wire_1.isConfigWithReceiver)(config)) {\n            await __classPrivateFieldGet(this, _Transport_wire, \"f\").connect(config.receiver);\n            return this.authorize(config);\n        }\n        if ((0, wire_1.isRemoteConfig)(config)) {\n            return this.connectRemote(config);\n        }\n        if ((0, wire_1.isExistingConnectConfig)(config)) {\n            return this.connectByPort(config);\n        }\n        if ((0, wire_1.isNewConnectConfig)(config)) {\n            const port = await this.environment.retrievePort(config);\n            return this.connectByPort({ ...config, address: `ws://localhost:${port}` });\n        }\n        return undefined;\n    }\n    async connectRemote(config) {\n        await __classPrivateFieldGet(this, _Transport_wire, \"f\").connect(new (this.environment.getWsConstructor())(config.address));\n        return this.authorize(config);\n    }\n    async connectByPort(config) {\n        const { address, uuid } = config;\n        const reqAuthPayload = { ...config, type: 'file-token' };\n        const wire = __classPrivateFieldGet(this, _Transport_wire, \"f\");\n        await wire.connect(new (this.environment.getWsConstructor())(config.address));\n        const requestExtAuthRet = await this.sendAction('request-external-authorization', {\n            uuid,\n            type: 'file-token'\n        }, true);\n        if (requestExtAuthRet.action !== 'external-authorization-response') {\n            throw new transport_errors_1.UnexpectedActionError(requestExtAuthRet.action);\n        }\n        await this.environment.writeToken(requestExtAuthRet.payload.file, requestExtAuthRet.payload.token);\n        return this.authorize(reqAuthPayload);\n    }\n    async authorize(reqAuthPayload) {\n        const requestAuthRet = await this.sendAction('request-authorization', reqAuthPayload, true);\n        if (requestAuthRet.action !== 'authorization-response') {\n            throw new transport_errors_1.UnexpectedActionError(requestAuthRet.action);\n        }\n        else if (requestAuthRet.payload.success !== true) {\n            throw new transport_errors_1.RuntimeError(requestAuthRet.payload);\n        }\n    }\n    sendAction(action, payload = {}, uncorrelated = false\n    // specialResponse type is only used for 'requestAuthorization'\n    ) {\n        // eslint-disable-next-line @typescript-eslint/no-empty-function\n        let cancel = () => { };\n        // We want the callsite from the caller of this function, not from here.\n        const callSites = transport_errors_1.RuntimeError.getCallSite(1);\n        const messageId = this.environment.getNextMessageId();\n        const prom = new Promise((resolve, reject) => {\n            cancel = reject;\n            const msg = {\n                action,\n                payload,\n                messageId\n            };\n            const wire = __classPrivateFieldGet(this, _Transport_wire, \"f\");\n            this.addWireListener(messageId, resolve, (payload) => this.nackHandler(payload, reject, callSites), uncorrelated);\n            return wire.send(msg).catch(reject);\n        });\n        return Object.assign(prom, { cancel, messageId });\n    }\n    nackHandler(payloadOrMessage, reject, callSites) {\n        if (typeof payloadOrMessage === 'string') {\n            // NOTE: this is for backwards compatibility to support plain string rejections\n            reject(payloadOrMessage);\n        }\n        else {\n            reject(new transport_errors_1.RuntimeError(payloadOrMessage, callSites));\n        }\n    }\n    ferryAction(origData) {\n        return new Promise((resolve, reject) => {\n            const id = this.environment.getNextMessageId();\n            origData.messageId = id;\n            const resolver = (data) => {\n                resolve(data.payload);\n            };\n            const wire = __classPrivateFieldGet(this, _Transport_wire, \"f\");\n            return wire\n                .send(origData)\n                .then(() => this.addWireListener(id, resolver, (payload) => this.nackHandler(payload, reject), false))\n                .catch(reject);\n        });\n    }\n    registerMessageHandler(handler) {\n        this.messageHandlers.push(handler);\n    }\n    addWireListener(id, resolve, handleNack, uncorrelated) {\n        if (uncorrelated) {\n            this.uncorrelatedListener = resolve;\n        }\n        else if (this.wireListeners.has(id)) {\n            handleNack({\n                reason: 'Duplicate handler id',\n                error: (0, errors_1.errorToPOJO)(new transport_errors_1.DuplicateCorrelationError(String(id)))\n            });\n        }\n        else {\n            this.wireListeners.set(id, { resolve, handleNack });\n        }\n        // Timeout and reject()?\n    }\n    // This method executes message handlers until the _one_ that handles the message (returns truthy) has run\n    onmessage(data) {\n        for (const h of this.messageHandlers) {\n            h.call(null, data);\n        }\n    }\n    handleMessage(data) {\n        const id = data.correlationId || NaN;\n        if (!('correlationId' in data)) {\n            if (this.uncorrelatedListener) {\n                this.uncorrelatedListener.call(null, data);\n            }\n            this.uncorrelatedListener = () => {\n                // empty block\n            };\n        }\n        else if (!this.wireListeners.has(id)) {\n            return false;\n        }\n        else {\n            // We just checked for existence above\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            const { resolve, handleNack } = this.wireListeners.get(id);\n            if (data.action !== 'ack') {\n                handleNack({ reason: 'Did not receive ack action', error: (0, errors_1.errorToPOJO)(new transport_errors_1.NoAckError(data.action)) });\n            }\n            else if (!('payload' in data)) {\n                // I'm not sure when this code would actually run, but passing in something that doeesn't have a reason to the runtimeerror constructor will not end well.\n                // @ts-expect-error\n                if (typeof data.reason === 'string') {\n                    handleNack(data);\n                }\n                else {\n                    console.warn('Received invalid response from core', data);\n                    handleNack({ reason: 'invalid response shape' });\n                }\n            }\n            else if (!data.payload.success) {\n                handleNack(data.payload);\n            }\n            else {\n                resolve.call(null, data);\n            }\n            this.wireListeners.delete(id);\n        }\n        return true;\n    }\n}\nTransport_1 = transport.Transport = Transport;\n_Transport_wire = new WeakMap(), _Transport_fin = new WeakMap();\n\nvar mockEnvironment = {};\n\nObject.defineProperty(mockEnvironment, \"__esModule\", { value: true });\nvar MockEnvironment_1 = mockEnvironment.MockEnvironment = void 0;\nconst me_1 = me;\nclass MockEnvironment {\n    constructor() {\n        this.type = 'other';\n        this.childViews = true;\n    }\n    getAdapterVersionSync() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    async getInteropInfo() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    getDefaultChannelOptions() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    getRtcPeer() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    layoutAllowedInContext(_fin) {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    initLayoutManager() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    applyLayoutSnapshot() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    async createLayout() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    async destroyLayout() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    async resolveLayout() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    initPlatform() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    observeBounds() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    writeToken(path, token) {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    retrievePort(config) {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    getNextMessageId() {\n        return `mock-message-id-${Math.random()}`;\n    }\n    getRandomId() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    createChildContent(options) {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    getWebWindow(identity) {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    getCurrentEntityIdentity() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    getCurrentEntityType() {\n        return 'unknown';\n    }\n    raiseEvent(eventName, eventArgs) {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    getUrl() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    whenReady() {\n        throw new Error(me_1.environmentUnsupportedMessage);\n    }\n    getWsConstructor() {\n        throw new Error('Method not implemented.');\n    }\n}\nMockEnvironment_1 = mockEnvironment.MockEnvironment = MockEnvironment;\n\nvar mockWire = {};\n\nObject.defineProperty(mockWire, \"__esModule\", { value: true });\nvar MockWire_1 = mockWire.MockWire = void 0;\n/* eslint-disable @typescript-eslint/no-unused-vars */\nconst events_1 = require$$0;\nclass MockWire extends events_1.EventEmitter {\n    connect() {\n        throw new Error('You are not running in OpenFin.');\n    }\n    connectSync() {\n        throw new Error('You are not running in OpenFin.');\n    }\n    send(data) {\n        throw new Error('You are not running in OpenFin.');\n    }\n    shutdown() {\n        throw new Error('You are not running in OpenFin.');\n    }\n    getPort() {\n        throw new Error('This transport has no port');\n    }\n    // eslint-disable-next-line no-useless-constructor\n    constructor() {\n        super();\n    }\n}\nMockWire_1 = mockWire.MockWire = MockWire;\n\nconst fin$1 = ((typeof window !== 'undefined' && window?.fin) ||\n    (() => {\n        const environment = new MockEnvironment_1();\n        const transport = new Transport_1(MockWire_1, environment, {\n            uuid: '',\n            name: ''\n        });\n        return new Fin_1(transport);\n    })());\n\nexports.OpenFin = OpenFin$1;\nexports.default = OpenFin$1;\nexports.fin = fin$1;\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar R = typeof Reflect === 'object' ? Reflect : null\nvar ReflectApply = R && typeof R.apply === 'function'\n  ? R.apply\n  : function ReflectApply(target, receiver, args) {\n    return Function.prototype.apply.call(target, receiver, args);\n  }\n\nvar ReflectOwnKeys\nif (R && typeof R.ownKeys === 'function') {\n  ReflectOwnKeys = R.ownKeys\n} else if (Object.getOwnPropertySymbols) {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target)\n      .concat(Object.getOwnPropertySymbols(target));\n  };\n} else {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target);\n  };\n}\n\nfunction ProcessEmitWarning(warning) {\n  if (console && console.warn) console.warn(warning);\n}\n\nvar NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {\n  return value !== value;\n}\n\nfunction EventEmitter() {\n  EventEmitter.init.call(this);\n}\nmodule.exports = EventEmitter;\nmodule.exports.once = once;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._eventsCount = 0;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nvar defaultMaxListeners = 10;\n\nfunction checkListener(listener) {\n  if (typeof listener !== 'function') {\n    throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n  }\n}\n\nObject.defineProperty(EventEmitter, 'defaultMaxListeners', {\n  enumerable: true,\n  get: function() {\n    return defaultMaxListeners;\n  },\n  set: function(arg) {\n    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {\n      throw new RangeError('The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received ' + arg + '.');\n    }\n    defaultMaxListeners = arg;\n  }\n});\n\nEventEmitter.init = function() {\n\n  if (this._events === undefined ||\n      this._events === Object.getPrototypeOf(this)._events) {\n    this._events = Object.create(null);\n    this._eventsCount = 0;\n  }\n\n  this._maxListeners = this._maxListeners || undefined;\n};\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {\n    throw new RangeError('The value of \"n\" is out of range. It must be a non-negative number. Received ' + n + '.');\n  }\n  this._maxListeners = n;\n  return this;\n};\n\nfunction _getMaxListeners(that) {\n  if (that._maxListeners === undefined)\n    return EventEmitter.defaultMaxListeners;\n  return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n  return _getMaxListeners(this);\n};\n\nEventEmitter.prototype.emit = function emit(type) {\n  var args = [];\n  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);\n  var doError = (type === 'error');\n\n  var events = this._events;\n  if (events !== undefined)\n    doError = (doError && events.error === undefined);\n  else if (!doError)\n    return false;\n\n  // If there is no 'error' event listener then throw.\n  if (doError) {\n    var er;\n    if (args.length > 0)\n      er = args[0];\n    if (er instanceof Error) {\n      // Note: The comments on the `throw` lines are intentional, they show\n      // up in Node's output if this results in an unhandled exception.\n      throw er; // Unhandled 'error' event\n    }\n    // At least give some kind of context to the user\n    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));\n    err.context = er;\n    throw err; // Unhandled 'error' event\n  }\n\n  var handler = events[type];\n\n  if (handler === undefined)\n    return false;\n\n  if (typeof handler === 'function') {\n    ReflectApply(handler, this, args);\n  } else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      ReflectApply(listeners[i], this, args);\n  }\n\n  return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n  var m;\n  var events;\n  var existing;\n\n  checkListener(listener);\n\n  events = target._events;\n  if (events === undefined) {\n    events = target._events = Object.create(null);\n    target._eventsCount = 0;\n  } else {\n    // To avoid recursion in the case that type === \"newListener\"! Before\n    // adding it to the listeners, first emit \"newListener\".\n    if (events.newListener !== undefined) {\n      target.emit('newListener', type,\n                  listener.listener ? listener.listener : listener);\n\n      // Re-assign `events` because a newListener handler could have caused the\n      // this._events to be assigned to a new object\n      events = target._events;\n    }\n    existing = events[type];\n  }\n\n  if (existing === undefined) {\n    // Optimize the case of one listener. Don't need the extra array object.\n    existing = events[type] = listener;\n    ++target._eventsCount;\n  } else {\n    if (typeof existing === 'function') {\n      // Adding the second element, need to change to array.\n      existing = events[type] =\n        prepend ? [listener, existing] : [existing, listener];\n      // If we've already got an array, just append.\n    } else if (prepend) {\n      existing.unshift(listener);\n    } else {\n      existing.push(listener);\n    }\n\n    // Check for listener leak\n    m = _getMaxListeners(target);\n    if (m > 0 && existing.length > m && !existing.warned) {\n      existing.warned = true;\n      // No error code for this since it is a Warning\n      // eslint-disable-next-line no-restricted-syntax\n      var w = new Error('Possible EventEmitter memory leak detected. ' +\n                          existing.length + ' ' + String(type) + ' listeners ' +\n                          'added. Use emitter.setMaxListeners() to ' +\n                          'increase limit');\n      w.name = 'MaxListenersExceededWarning';\n      w.emitter = target;\n      w.type = type;\n      w.count = existing.length;\n      ProcessEmitWarning(w);\n    }\n  }\n\n  return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n  return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener =\n    function prependListener(type, listener) {\n      return _addListener(this, type, listener, true);\n    };\n\nfunction onceWrapper() {\n  if (!this.fired) {\n    this.target.removeListener(this.type, this.wrapFn);\n    this.fired = true;\n    if (arguments.length === 0)\n      return this.listener.call(this.target);\n    return this.listener.apply(this.target, arguments);\n  }\n}\n\nfunction _onceWrap(target, type, listener) {\n  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n  var wrapped = onceWrapper.bind(state);\n  wrapped.listener = listener;\n  state.wrapFn = wrapped;\n  return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n  checkListener(listener);\n  this.on(type, _onceWrap(this, type, listener));\n  return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n    function prependOnceListener(type, listener) {\n      checkListener(listener);\n      this.prependListener(type, _onceWrap(this, type, listener));\n      return this;\n    };\n\n// Emits a 'removeListener' event if and only if the listener was removed.\nEventEmitter.prototype.removeListener =\n    function removeListener(type, listener) {\n      var list, events, position, i, originalListener;\n\n      checkListener(listener);\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      list = events[type];\n      if (list === undefined)\n        return this;\n\n      if (list === listener || list.listener === listener) {\n        if (--this._eventsCount === 0)\n          this._events = Object.create(null);\n        else {\n          delete events[type];\n          if (events.removeListener)\n            this.emit('removeListener', type, list.listener || listener);\n        }\n      } else if (typeof list !== 'function') {\n        position = -1;\n\n        for (i = list.length - 1; i >= 0; i--) {\n          if (list[i] === listener || list[i].listener === listener) {\n            originalListener = list[i].listener;\n            position = i;\n            break;\n          }\n        }\n\n        if (position < 0)\n          return this;\n\n        if (position === 0)\n          list.shift();\n        else {\n          spliceOne(list, position);\n        }\n\n        if (list.length === 1)\n          events[type] = list[0];\n\n        if (events.removeListener !== undefined)\n          this.emit('removeListener', type, originalListener || listener);\n      }\n\n      return this;\n    };\n\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\n\nEventEmitter.prototype.removeAllListeners =\n    function removeAllListeners(type) {\n      var listeners, events, i;\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      // not listening for removeListener, no need to emit\n      if (events.removeListener === undefined) {\n        if (arguments.length === 0) {\n          this._events = Object.create(null);\n          this._eventsCount = 0;\n        } else if (events[type] !== undefined) {\n          if (--this._eventsCount === 0)\n            this._events = Object.create(null);\n          else\n            delete events[type];\n        }\n        return this;\n      }\n\n      // emit removeListener for all listeners on all events\n      if (arguments.length === 0) {\n        var keys = Object.keys(events);\n        var key;\n        for (i = 0; i < keys.length; ++i) {\n          key = keys[i];\n          if (key === 'removeListener') continue;\n          this.removeAllListeners(key);\n        }\n        this.removeAllListeners('removeListener');\n        this._events = Object.create(null);\n        this._eventsCount = 0;\n        return this;\n      }\n\n      listeners = events[type];\n\n      if (typeof listeners === 'function') {\n        this.removeListener(type, listeners);\n      } else if (listeners !== undefined) {\n        // LIFO order\n        for (i = listeners.length - 1; i >= 0; i--) {\n          this.removeListener(type, listeners[i]);\n        }\n      }\n\n      return this;\n    };\n\nfunction _listeners(target, type, unwrap) {\n  var events = target._events;\n\n  if (events === undefined)\n    return [];\n\n  var evlistener = events[type];\n  if (evlistener === undefined)\n    return [];\n\n  if (typeof evlistener === 'function')\n    return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n\n  return unwrap ?\n    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n  return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n  return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  if (typeof emitter.listenerCount === 'function') {\n    return emitter.listenerCount(type);\n  } else {\n    return listenerCount.call(emitter, type);\n  }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n  var events = this._events;\n\n  if (events !== undefined) {\n    var evlistener = events[type];\n\n    if (typeof evlistener === 'function') {\n      return 1;\n    } else if (evlistener !== undefined) {\n      return evlistener.length;\n    }\n  }\n\n  return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];\n};\n\nfunction arrayClone(arr, n) {\n  var copy = new Array(n);\n  for (var i = 0; i < n; ++i)\n    copy[i] = arr[i];\n  return copy;\n}\n\nfunction spliceOne(list, index) {\n  for (; index + 1 < list.length; index++)\n    list[index] = list[index + 1];\n  list.pop();\n}\n\nfunction unwrapListeners(arr) {\n  var ret = new Array(arr.length);\n  for (var i = 0; i < ret.length; ++i) {\n    ret[i] = arr[i].listener || arr[i];\n  }\n  return ret;\n}\n\nfunction once(emitter, name) {\n  return new Promise(function (resolve, reject) {\n    function errorListener(err) {\n      emitter.removeListener(name, resolver);\n      reject(err);\n    }\n\n    function resolver() {\n      if (typeof emitter.removeListener === 'function') {\n        emitter.removeListener('error', errorListener);\n      }\n      resolve([].slice.call(arguments));\n    };\n\n    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });\n    if (name !== 'error') {\n      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });\n    }\n  });\n}\n\nfunction addErrorHandlerIfEventEmitter(emitter, handler, flags) {\n  if (typeof emitter.on === 'function') {\n    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);\n  }\n}\n\nfunction eventTargetAgnosticAddListener(emitter, name, listener, flags) {\n  if (typeof emitter.on === 'function') {\n    if (flags.once) {\n      emitter.once(name, listener);\n    } else {\n      emitter.on(name, listener);\n    }\n  } else if (typeof emitter.addEventListener === 'function') {\n    // EventTarget does not have `error` event semantics like Node\n    // EventEmitters, we do not listen for `error` events here.\n    emitter.addEventListener(name, function wrapListener(arg) {\n      // IE does not have builtin `{ once: true }` support so we\n      // have to do it manually.\n      if (flags.once) {\n        emitter.removeEventListener(name, wrapListener);\n      }\n      listener(arg);\n    });\n  } else {\n    throw new TypeError('The \"emitter\" argument must be of type EventEmitter. Received type ' + typeof emitter);\n  }\n}\n","var getNative = require('./_getNative'),\n    root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar DataView = getNative(root, 'DataView');\n\nmodule.exports = DataView;\n","var hashClear = require('./_hashClear'),\n    hashDelete = require('./_hashDelete'),\n    hashGet = require('./_hashGet'),\n    hashHas = require('./_hashHas'),\n    hashSet = require('./_hashSet');\n\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Hash(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\nmodule.exports = Hash;\n","var listCacheClear = require('./_listCacheClear'),\n    listCacheDelete = require('./_listCacheDelete'),\n    listCacheGet = require('./_listCacheGet'),\n    listCacheHas = require('./_listCacheHas'),\n    listCacheSet = require('./_listCacheSet');\n\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction ListCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\nmodule.exports = ListCache;\n","var getNative = require('./_getNative'),\n    root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar Map = getNative(root, 'Map');\n\nmodule.exports = Map;\n","var mapCacheClear = require('./_mapCacheClear'),\n    mapCacheDelete = require('./_mapCacheDelete'),\n    mapCacheGet = require('./_mapCacheGet'),\n    mapCacheHas = require('./_mapCacheHas'),\n    mapCacheSet = require('./_mapCacheSet');\n\n/**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction MapCache(entries) {\n  var index = -1,\n      length = entries == null ? 0 : entries.length;\n\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\nmodule.exports = MapCache;\n","var getNative = require('./_getNative'),\n    root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar Promise = getNative(root, 'Promise');\n\nmodule.exports = Promise;\n","var getNative = require('./_getNative'),\n    root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar Set = getNative(root, 'Set');\n\nmodule.exports = Set;\n","var MapCache = require('./_MapCache'),\n    setCacheAdd = require('./_setCacheAdd'),\n    setCacheHas = require('./_setCacheHas');\n\n/**\n *\n * Creates an array cache object to store unique values.\n *\n * @private\n * @constructor\n * @param {Array} [values] The values to cache.\n */\nfunction SetCache(values) {\n  var index = -1,\n      length = values == null ? 0 : values.length;\n\n  this.__data__ = new MapCache;\n  while (++index < length) {\n    this.add(values[index]);\n  }\n}\n\n// Add methods to `SetCache`.\nSetCache.prototype.add = SetCache.prototype.push = setCacheAdd;\nSetCache.prototype.has = setCacheHas;\n\nmodule.exports = SetCache;\n","var ListCache = require('./_ListCache'),\n    stackClear = require('./_stackClear'),\n    stackDelete = require('./_stackDelete'),\n    stackGet = require('./_stackGet'),\n    stackHas = require('./_stackHas'),\n    stackSet = require('./_stackSet');\n\n/**\n * Creates a stack cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Stack(entries) {\n  var data = this.__data__ = new ListCache(entries);\n  this.size = data.size;\n}\n\n// Add methods to `Stack`.\nStack.prototype.clear = stackClear;\nStack.prototype['delete'] = stackDelete;\nStack.prototype.get = stackGet;\nStack.prototype.has = stackHas;\nStack.prototype.set = stackSet;\n\nmodule.exports = Stack;\n","var root = require('./_root');\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nmodule.exports = Symbol;\n","var root = require('./_root');\n\n/** Built-in value references. */\nvar Uint8Array = root.Uint8Array;\n\nmodule.exports = Uint8Array;\n","var getNative = require('./_getNative'),\n    root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar WeakMap = getNative(root, 'WeakMap');\n\nmodule.exports = WeakMap;\n","/**\n * A specialized version of `_.forEach` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns `array`.\n */\nfunction arrayEach(array, iteratee) {\n  var index = -1,\n      length = array == null ? 0 : array.length;\n\n  while (++index < length) {\n    if (iteratee(array[index], index, array) === false) {\n      break;\n    }\n  }\n  return array;\n}\n\nmodule.exports = arrayEach;\n","/**\n * A specialized version of `_.filter` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {Array} Returns the new filtered array.\n */\nfunction arrayFilter(array, predicate) {\n  var index = -1,\n      length = array == null ? 0 : array.length,\n      resIndex = 0,\n      result = [];\n\n  while (++index < length) {\n    var value = array[index];\n    if (predicate(value, index, array)) {\n      result[resIndex++] = value;\n    }\n  }\n  return result;\n}\n\nmodule.exports = arrayFilter;\n","var baseTimes = require('./_baseTimes'),\n    isArguments = require('./isArguments'),\n    isArray = require('./isArray'),\n    isBuffer = require('./isBuffer'),\n    isIndex = require('./_isIndex'),\n    isTypedArray = require('./isTypedArray');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n  var isArr = isArray(value),\n      isArg = !isArr && isArguments(value),\n      isBuff = !isArr && !isArg && isBuffer(value),\n      isType = !isArr && !isArg && !isBuff && isTypedArray(value),\n      skipIndexes = isArr || isArg || isBuff || isType,\n      result = skipIndexes ? baseTimes(value.length, String) : [],\n      length = result.length;\n\n  for (var key in value) {\n    if ((inherited || hasOwnProperty.call(value, key)) &&\n        !(skipIndexes && (\n           // Safari 9 has enumerable `arguments.length` in strict mode.\n           key == 'length' ||\n           // Node.js 0.10 has enumerable non-index properties on buffers.\n           (isBuff && (key == 'offset' || key == 'parent')) ||\n           // PhantomJS 2 has enumerable non-index properties on typed arrays.\n           (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||\n           // Skip index properties.\n           isIndex(key, length)\n        ))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nmodule.exports = arrayLikeKeys;\n","/**\n * Appends the elements of `values` to `array`.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to append.\n * @returns {Array} Returns `array`.\n */\nfunction arrayPush(array, values) {\n  var index = -1,\n      length = values.length,\n      offset = array.length;\n\n  while (++index < length) {\n    array[offset + index] = values[index];\n  }\n  return array;\n}\n\nmodule.exports = arrayPush;\n","/**\n * A specialized version of `_.some` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {boolean} Returns `true` if any element passes the predicate check,\n *  else `false`.\n */\nfunction arraySome(array, predicate) {\n  var index = -1,\n      length = array == null ? 0 : array.length;\n\n  while (++index < length) {\n    if (predicate(array[index], index, array)) {\n      return true;\n    }\n  }\n  return false;\n}\n\nmodule.exports = arraySome;\n","var baseAssignValue = require('./_baseAssignValue'),\n    eq = require('./eq');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Assigns `value` to `key` of `object` if the existing value is not equivalent\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignValue(object, key, value) {\n  var objValue = object[key];\n  if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||\n      (value === undefined && !(key in object))) {\n    baseAssignValue(object, key, value);\n  }\n}\n\nmodule.exports = assignValue;\n","var eq = require('./eq');\n\n/**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction assocIndexOf(array, key) {\n  var length = array.length;\n  while (length--) {\n    if (eq(array[length][0], key)) {\n      return length;\n    }\n  }\n  return -1;\n}\n\nmodule.exports = assocIndexOf;\n","var copyObject = require('./_copyObject'),\n    keys = require('./keys');\n\n/**\n * The base implementation of `_.assign` without support for multiple sources\n * or `customizer` functions.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @returns {Object} Returns `object`.\n */\nfunction baseAssign(object, source) {\n  return object && copyObject(source, keys(source), object);\n}\n\nmodule.exports = baseAssign;\n","var copyObject = require('./_copyObject'),\n    keysIn = require('./keysIn');\n\n/**\n * The base implementation of `_.assignIn` without support for multiple sources\n * or `customizer` functions.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @returns {Object} Returns `object`.\n */\nfunction baseAssignIn(object, source) {\n  return object && copyObject(source, keysIn(source), object);\n}\n\nmodule.exports = baseAssignIn;\n","var defineProperty = require('./_defineProperty');\n\n/**\n * The base implementation of `assignValue` and `assignMergeValue` without\n * value checks.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction baseAssignValue(object, key, value) {\n  if (key == '__proto__' && defineProperty) {\n    defineProperty(object, key, {\n      'configurable': true,\n      'enumerable': true,\n      'value': value,\n      'writable': true\n    });\n  } else {\n    object[key] = value;\n  }\n}\n\nmodule.exports = baseAssignValue;\n","var Stack = require('./_Stack'),\n    arrayEach = require('./_arrayEach'),\n    assignValue = require('./_assignValue'),\n    baseAssign = require('./_baseAssign'),\n    baseAssignIn = require('./_baseAssignIn'),\n    cloneBuffer = require('./_cloneBuffer'),\n    copyArray = require('./_copyArray'),\n    copySymbols = require('./_copySymbols'),\n    copySymbolsIn = require('./_copySymbolsIn'),\n    getAllKeys = require('./_getAllKeys'),\n    getAllKeysIn = require('./_getAllKeysIn'),\n    getTag = require('./_getTag'),\n    initCloneArray = require('./_initCloneArray'),\n    initCloneByTag = require('./_initCloneByTag'),\n    initCloneObject = require('./_initCloneObject'),\n    isArray = require('./isArray'),\n    isBuffer = require('./isBuffer'),\n    isMap = require('./isMap'),\n    isObject = require('./isObject'),\n    isSet = require('./isSet'),\n    keys = require('./keys'),\n    keysIn = require('./keysIn');\n\n/** Used to compose bitmasks for cloning. */\nvar CLONE_DEEP_FLAG = 1,\n    CLONE_FLAT_FLAG = 2,\n    CLONE_SYMBOLS_FLAG = 4;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    objectTag = '[object Object]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    symbolTag = '[object Symbol]',\n    weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]',\n    float32Tag = '[object Float32Array]',\n    float64Tag = '[object Float64Array]',\n    int8Tag = '[object Int8Array]',\n    int16Tag = '[object Int16Array]',\n    int32Tag = '[object Int32Array]',\n    uint8Tag = '[object Uint8Array]',\n    uint8ClampedTag = '[object Uint8ClampedArray]',\n    uint16Tag = '[object Uint16Array]',\n    uint32Tag = '[object Uint32Array]';\n\n/** Used to identify `toStringTag` values supported by `_.clone`. */\nvar cloneableTags = {};\ncloneableTags[argsTag] = cloneableTags[arrayTag] =\ncloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =\ncloneableTags[boolTag] = cloneableTags[dateTag] =\ncloneableTags[float32Tag] = cloneableTags[float64Tag] =\ncloneableTags[int8Tag] = cloneableTags[int16Tag] =\ncloneableTags[int32Tag] = cloneableTags[mapTag] =\ncloneableTags[numberTag] = cloneableTags[objectTag] =\ncloneableTags[regexpTag] = cloneableTags[setTag] =\ncloneableTags[stringTag] = cloneableTags[symbolTag] =\ncloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =\ncloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;\ncloneableTags[errorTag] = cloneableTags[funcTag] =\ncloneableTags[weakMapTag] = false;\n\n/**\n * The base implementation of `_.clone` and `_.cloneDeep` which tracks\n * traversed objects.\n *\n * @private\n * @param {*} value The value to clone.\n * @param {boolean} bitmask The bitmask flags.\n *  1 - Deep clone\n *  2 - Flatten inherited properties\n *  4 - Clone symbols\n * @param {Function} [customizer] The function to customize cloning.\n * @param {string} [key] The key of `value`.\n * @param {Object} [object] The parent object of `value`.\n * @param {Object} [stack] Tracks traversed objects and their clone counterparts.\n * @returns {*} Returns the cloned value.\n */\nfunction baseClone(value, bitmask, customizer, key, object, stack) {\n  var result,\n      isDeep = bitmask & CLONE_DEEP_FLAG,\n      isFlat = bitmask & CLONE_FLAT_FLAG,\n      isFull = bitmask & CLONE_SYMBOLS_FLAG;\n\n  if (customizer) {\n    result = object ? customizer(value, key, object, stack) : customizer(value);\n  }\n  if (result !== undefined) {\n    return result;\n  }\n  if (!isObject(value)) {\n    return value;\n  }\n  var isArr = isArray(value);\n  if (isArr) {\n    result = initCloneArray(value);\n    if (!isDeep) {\n      return copyArray(value, result);\n    }\n  } else {\n    var tag = getTag(value),\n        isFunc = tag == funcTag || tag == genTag;\n\n    if (isBuffer(value)) {\n      return cloneBuffer(value, isDeep);\n    }\n    if (tag == objectTag || tag == argsTag || (isFunc && !object)) {\n      result = (isFlat || isFunc) ? {} : initCloneObject(value);\n      if (!isDeep) {\n        return isFlat\n          ? copySymbolsIn(value, baseAssignIn(result, value))\n          : copySymbols(value, baseAssign(result, value));\n      }\n    } else {\n      if (!cloneableTags[tag]) {\n        return object ? value : {};\n      }\n      result = initCloneByTag(value, tag, isDeep);\n    }\n  }\n  // Check for circular references and return its corresponding clone.\n  stack || (stack = new Stack);\n  var stacked = stack.get(value);\n  if (stacked) {\n    return stacked;\n  }\n  stack.set(value, result);\n\n  if (isSet(value)) {\n    value.forEach(function(subValue) {\n      result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));\n    });\n  } else if (isMap(value)) {\n    value.forEach(function(subValue, key) {\n      result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));\n    });\n  }\n\n  var keysFunc = isFull\n    ? (isFlat ? getAllKeysIn : getAllKeys)\n    : (isFlat ? keysIn : keys);\n\n  var props = isArr ? undefined : keysFunc(value);\n  arrayEach(props || value, function(subValue, key) {\n    if (props) {\n      key = subValue;\n      subValue = value[key];\n    }\n    // Recursively populate clone (susceptible to call stack limits).\n    assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));\n  });\n  return result;\n}\n\nmodule.exports = baseClone;\n","var isObject = require('./isObject');\n\n/** Built-in value references. */\nvar objectCreate = Object.create;\n\n/**\n * The base implementation of `_.create` without support for assigning\n * properties to the created object.\n *\n * @private\n * @param {Object} proto The object to inherit from.\n * @returns {Object} Returns the new object.\n */\nvar baseCreate = (function() {\n  function object() {}\n  return function(proto) {\n    if (!isObject(proto)) {\n      return {};\n    }\n    if (objectCreate) {\n      return objectCreate(proto);\n    }\n    object.prototype = proto;\n    var result = new object;\n    object.prototype = undefined;\n    return result;\n  };\n}());\n\nmodule.exports = baseCreate;\n","var arrayPush = require('./_arrayPush'),\n    isArray = require('./isArray');\n\n/**\n * The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @param {Function} symbolsFunc The function to get the symbols of `object`.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction baseGetAllKeys(object, keysFunc, symbolsFunc) {\n  var result = keysFunc(object);\n  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n}\n\nmodule.exports = baseGetAllKeys;\n","var Symbol = require('./_Symbol'),\n    getRawTag = require('./_getRawTag'),\n    objectToString = require('./_objectToString');\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n    undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag && symToStringTag in Object(value))\n    ? getRawTag(value)\n    : objectToString(value);\n}\n\nmodule.exports = baseGetTag;\n","var baseGetTag = require('./_baseGetTag'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]';\n\n/**\n * The base implementation of `_.isArguments`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n */\nfunction baseIsArguments(value) {\n  return isObjectLike(value) && baseGetTag(value) == argsTag;\n}\n\nmodule.exports = baseIsArguments;\n","var baseIsEqualDeep = require('./_baseIsEqualDeep'),\n    isObjectLike = require('./isObjectLike');\n\n/**\n * The base implementation of `_.isEqual` which supports partial comparisons\n * and tracks traversed objects.\n *\n * @private\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @param {boolean} bitmask The bitmask flags.\n *  1 - Unordered comparison\n *  2 - Partial comparison\n * @param {Function} [customizer] The function to customize comparisons.\n * @param {Object} [stack] Tracks traversed `value` and `other` objects.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n */\nfunction baseIsEqual(value, other, bitmask, customizer, stack) {\n  if (value === other) {\n    return true;\n  }\n  if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {\n    return value !== value && other !== other;\n  }\n  return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);\n}\n\nmodule.exports = baseIsEqual;\n","var Stack = require('./_Stack'),\n    equalArrays = require('./_equalArrays'),\n    equalByTag = require('./_equalByTag'),\n    equalObjects = require('./_equalObjects'),\n    getTag = require('./_getTag'),\n    isArray = require('./isArray'),\n    isBuffer = require('./isBuffer'),\n    isTypedArray = require('./isTypedArray');\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    objectTag = '[object Object]';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * A specialized version of `baseIsEqual` for arrays and objects which performs\n * deep comparisons and tracks traversed objects enabling objects with circular\n * references to be compared.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} [stack] Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {\n  var objIsArr = isArray(object),\n      othIsArr = isArray(other),\n      objTag = objIsArr ? arrayTag : getTag(object),\n      othTag = othIsArr ? arrayTag : getTag(other);\n\n  objTag = objTag == argsTag ? objectTag : objTag;\n  othTag = othTag == argsTag ? objectTag : othTag;\n\n  var objIsObj = objTag == objectTag,\n      othIsObj = othTag == objectTag,\n      isSameTag = objTag == othTag;\n\n  if (isSameTag && isBuffer(object)) {\n    if (!isBuffer(other)) {\n      return false;\n    }\n    objIsArr = true;\n    objIsObj = false;\n  }\n  if (isSameTag && !objIsObj) {\n    stack || (stack = new Stack);\n    return (objIsArr || isTypedArray(object))\n      ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)\n      : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);\n  }\n  if (!(bitmask & COMPARE_PARTIAL_FLAG)) {\n    var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),\n        othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');\n\n    if (objIsWrapped || othIsWrapped) {\n      var objUnwrapped = objIsWrapped ? object.value() : object,\n          othUnwrapped = othIsWrapped ? other.value() : other;\n\n      stack || (stack = new Stack);\n      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);\n    }\n  }\n  if (!isSameTag) {\n    return false;\n  }\n  stack || (stack = new Stack);\n  return equalObjects(object, other, bitmask, customizer, equalFunc, stack);\n}\n\nmodule.exports = baseIsEqualDeep;\n","var getTag = require('./_getTag'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar mapTag = '[object Map]';\n\n/**\n * The base implementation of `_.isMap` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a map, else `false`.\n */\nfunction baseIsMap(value) {\n  return isObjectLike(value) && getTag(value) == mapTag;\n}\n\nmodule.exports = baseIsMap;\n","var isFunction = require('./isFunction'),\n    isMasked = require('./_isMasked'),\n    isObject = require('./isObject'),\n    toSource = require('./_toSource');\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n    objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n  .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n *  else `false`.\n */\nfunction baseIsNative(value) {\n  if (!isObject(value) || isMasked(value)) {\n    return false;\n  }\n  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n  return pattern.test(toSource(value));\n}\n\nmodule.exports = baseIsNative;\n","var getTag = require('./_getTag'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar setTag = '[object Set]';\n\n/**\n * The base implementation of `_.isSet` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a set, else `false`.\n */\nfunction baseIsSet(value) {\n  return isObjectLike(value) && getTag(value) == setTag;\n}\n\nmodule.exports = baseIsSet;\n","var baseGetTag = require('./_baseGetTag'),\n    isLength = require('./isLength'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    funcTag = '[object Function]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    objectTag = '[object Object]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]',\n    float32Tag = '[object Float32Array]',\n    float64Tag = '[object Float64Array]',\n    int8Tag = '[object Int8Array]',\n    int16Tag = '[object Int16Array]',\n    int32Tag = '[object Int32Array]',\n    uint8Tag = '[object Uint8Array]',\n    uint8ClampedTag = '[object Uint8ClampedArray]',\n    uint16Tag = '[object Uint16Array]',\n    uint32Tag = '[object Uint32Array]';\n\n/** Used to identify `toStringTag` values of typed arrays. */\nvar typedArrayTags = {};\ntypedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\ntypedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\ntypedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\ntypedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\ntypedArrayTags[uint32Tag] = true;\ntypedArrayTags[argsTag] = typedArrayTags[arrayTag] =\ntypedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\ntypedArrayTags[dataViewTag] = typedArrayTags[dateTag] =\ntypedArrayTags[errorTag] = typedArrayTags[funcTag] =\ntypedArrayTags[mapTag] = typedArrayTags[numberTag] =\ntypedArrayTags[objectTag] = typedArrayTags[regexpTag] =\ntypedArrayTags[setTag] = typedArrayTags[stringTag] =\ntypedArrayTags[weakMapTag] = false;\n\n/**\n * The base implementation of `_.isTypedArray` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n */\nfunction baseIsTypedArray(value) {\n  return isObjectLike(value) &&\n    isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n}\n\nmodule.exports = baseIsTypedArray;\n","var isPrototype = require('./_isPrototype'),\n    nativeKeys = require('./_nativeKeys');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeys(object) {\n  if (!isPrototype(object)) {\n    return nativeKeys(object);\n  }\n  var result = [];\n  for (var key in Object(object)) {\n    if (hasOwnProperty.call(object, key) && key != 'constructor') {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nmodule.exports = baseKeys;\n","var isObject = require('./isObject'),\n    isPrototype = require('./_isPrototype'),\n    nativeKeysIn = require('./_nativeKeysIn');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeysIn(object) {\n  if (!isObject(object)) {\n    return nativeKeysIn(object);\n  }\n  var isProto = isPrototype(object),\n      result = [];\n\n  for (var key in object) {\n    if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nmodule.exports = baseKeysIn;\n","/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n  var index = -1,\n      result = Array(n);\n\n  while (++index < n) {\n    result[index] = iteratee(index);\n  }\n  return result;\n}\n\nmodule.exports = baseTimes;\n","/**\n * The base implementation of `_.unary` without support for storing metadata.\n *\n * @private\n * @param {Function} func The function to cap arguments for.\n * @returns {Function} Returns the new capped function.\n */\nfunction baseUnary(func) {\n  return function(value) {\n    return func(value);\n  };\n}\n\nmodule.exports = baseUnary;\n","/**\n * Checks if a `cache` value for `key` exists.\n *\n * @private\n * @param {Object} cache The cache to query.\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction cacheHas(cache, key) {\n  return cache.has(key);\n}\n\nmodule.exports = cacheHas;\n","var Uint8Array = require('./_Uint8Array');\n\n/**\n * Creates a clone of `arrayBuffer`.\n *\n * @private\n * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n * @returns {ArrayBuffer} Returns the cloned array buffer.\n */\nfunction cloneArrayBuffer(arrayBuffer) {\n  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n  new Uint8Array(result).set(new Uint8Array(arrayBuffer));\n  return result;\n}\n\nmodule.exports = cloneArrayBuffer;\n","var root = require('./_root');\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined,\n    allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined;\n\n/**\n * Creates a clone of  `buffer`.\n *\n * @private\n * @param {Buffer} buffer The buffer to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Buffer} Returns the cloned buffer.\n */\nfunction cloneBuffer(buffer, isDeep) {\n  if (isDeep) {\n    return buffer.slice();\n  }\n  var length = buffer.length,\n      result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);\n\n  buffer.copy(result);\n  return result;\n}\n\nmodule.exports = cloneBuffer;\n","var cloneArrayBuffer = require('./_cloneArrayBuffer');\n\n/**\n * Creates a clone of `dataView`.\n *\n * @private\n * @param {Object} dataView The data view to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned data view.\n */\nfunction cloneDataView(dataView, isDeep) {\n  var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;\n  return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);\n}\n\nmodule.exports = cloneDataView;\n","/** Used to match `RegExp` flags from their coerced string values. */\nvar reFlags = /\\w*$/;\n\n/**\n * Creates a clone of `regexp`.\n *\n * @private\n * @param {Object} regexp The regexp to clone.\n * @returns {Object} Returns the cloned regexp.\n */\nfunction cloneRegExp(regexp) {\n  var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));\n  result.lastIndex = regexp.lastIndex;\n  return result;\n}\n\nmodule.exports = cloneRegExp;\n","var Symbol = require('./_Symbol');\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;\n\n/**\n * Creates a clone of the `symbol` object.\n *\n * @private\n * @param {Object} symbol The symbol object to clone.\n * @returns {Object} Returns the cloned symbol object.\n */\nfunction cloneSymbol(symbol) {\n  return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};\n}\n\nmodule.exports = cloneSymbol;\n","var cloneArrayBuffer = require('./_cloneArrayBuffer');\n\n/**\n * Creates a clone of `typedArray`.\n *\n * @private\n * @param {Object} typedArray The typed array to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned typed array.\n */\nfunction cloneTypedArray(typedArray, isDeep) {\n  var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n}\n\nmodule.exports = cloneTypedArray;\n","/**\n * Copies the values of `source` to `array`.\n *\n * @private\n * @param {Array} source The array to copy values from.\n * @param {Array} [array=[]] The array to copy values to.\n * @returns {Array} Returns `array`.\n */\nfunction copyArray(source, array) {\n  var index = -1,\n      length = source.length;\n\n  array || (array = Array(length));\n  while (++index < length) {\n    array[index] = source[index];\n  }\n  return array;\n}\n\nmodule.exports = copyArray;\n","var assignValue = require('./_assignValue'),\n    baseAssignValue = require('./_baseAssignValue');\n\n/**\n * Copies properties of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property identifiers to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @param {Function} [customizer] The function to customize copied values.\n * @returns {Object} Returns `object`.\n */\nfunction copyObject(source, props, object, customizer) {\n  var isNew = !object;\n  object || (object = {});\n\n  var index = -1,\n      length = props.length;\n\n  while (++index < length) {\n    var key = props[index];\n\n    var newValue = customizer\n      ? customizer(object[key], source[key], key, object, source)\n      : undefined;\n\n    if (newValue === undefined) {\n      newValue = source[key];\n    }\n    if (isNew) {\n      baseAssignValue(object, key, newValue);\n    } else {\n      assignValue(object, key, newValue);\n    }\n  }\n  return object;\n}\n\nmodule.exports = copyObject;\n","var copyObject = require('./_copyObject'),\n    getSymbols = require('./_getSymbols');\n\n/**\n * Copies own symbols of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy symbols from.\n * @param {Object} [object={}] The object to copy symbols to.\n * @returns {Object} Returns `object`.\n */\nfunction copySymbols(source, object) {\n  return copyObject(source, getSymbols(source), object);\n}\n\nmodule.exports = copySymbols;\n","var copyObject = require('./_copyObject'),\n    getSymbolsIn = require('./_getSymbolsIn');\n\n/**\n * Copies own and inherited symbols of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy symbols from.\n * @param {Object} [object={}] The object to copy symbols to.\n * @returns {Object} Returns `object`.\n */\nfunction copySymbolsIn(source, object) {\n  return copyObject(source, getSymbolsIn(source), object);\n}\n\nmodule.exports = copySymbolsIn;\n","var root = require('./_root');\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\nmodule.exports = coreJsData;\n","var getNative = require('./_getNative');\n\nvar defineProperty = (function() {\n  try {\n    var func = getNative(Object, 'defineProperty');\n    func({}, '', {});\n    return func;\n  } catch (e) {}\n}());\n\nmodule.exports = defineProperty;\n","var SetCache = require('./_SetCache'),\n    arraySome = require('./_arraySome'),\n    cacheHas = require('./_cacheHas');\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n    COMPARE_UNORDERED_FLAG = 2;\n\n/**\n * A specialized version of `baseIsEqualDeep` for arrays with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Array} array The array to compare.\n * @param {Array} other The other array to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `array` and `other` objects.\n * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.\n */\nfunction equalArrays(array, other, bitmask, customizer, equalFunc, stack) {\n  var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n      arrLength = array.length,\n      othLength = other.length;\n\n  if (arrLength != othLength && !(isPartial && othLength > arrLength)) {\n    return false;\n  }\n  // Check that cyclic values are equal.\n  var arrStacked = stack.get(array);\n  var othStacked = stack.get(other);\n  if (arrStacked && othStacked) {\n    return arrStacked == other && othStacked == array;\n  }\n  var index = -1,\n      result = true,\n      seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;\n\n  stack.set(array, other);\n  stack.set(other, array);\n\n  // Ignore non-index properties.\n  while (++index < arrLength) {\n    var arrValue = array[index],\n        othValue = other[index];\n\n    if (customizer) {\n      var compared = isPartial\n        ? customizer(othValue, arrValue, index, other, array, stack)\n        : customizer(arrValue, othValue, index, array, other, stack);\n    }\n    if (compared !== undefined) {\n      if (compared) {\n        continue;\n      }\n      result = false;\n      break;\n    }\n    // Recursively compare arrays (susceptible to call stack limits).\n    if (seen) {\n      if (!arraySome(other, function(othValue, othIndex) {\n            if (!cacheHas(seen, othIndex) &&\n                (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {\n              return seen.push(othIndex);\n            }\n          })) {\n        result = false;\n        break;\n      }\n    } else if (!(\n          arrValue === othValue ||\n            equalFunc(arrValue, othValue, bitmask, customizer, stack)\n        )) {\n      result = false;\n      break;\n    }\n  }\n  stack['delete'](array);\n  stack['delete'](other);\n  return result;\n}\n\nmodule.exports = equalArrays;\n","var Symbol = require('./_Symbol'),\n    Uint8Array = require('./_Uint8Array'),\n    eq = require('./eq'),\n    equalArrays = require('./_equalArrays'),\n    mapToArray = require('./_mapToArray'),\n    setToArray = require('./_setToArray');\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n    COMPARE_UNORDERED_FLAG = 2;\n\n/** `Object#toString` result references. */\nvar boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    symbolTag = '[object Symbol]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]';\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;\n\n/**\n * A specialized version of `baseIsEqualDeep` for comparing objects of\n * the same `toStringTag`.\n *\n * **Note:** This function only supports comparing values with tags of\n * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {string} tag The `toStringTag` of the objects to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {\n  switch (tag) {\n    case dataViewTag:\n      if ((object.byteLength != other.byteLength) ||\n          (object.byteOffset != other.byteOffset)) {\n        return false;\n      }\n      object = object.buffer;\n      other = other.buffer;\n\n    case arrayBufferTag:\n      if ((object.byteLength != other.byteLength) ||\n          !equalFunc(new Uint8Array(object), new Uint8Array(other))) {\n        return false;\n      }\n      return true;\n\n    case boolTag:\n    case dateTag:\n    case numberTag:\n      // Coerce booleans to `1` or `0` and dates to milliseconds.\n      // Invalid dates are coerced to `NaN`.\n      return eq(+object, +other);\n\n    case errorTag:\n      return object.name == other.name && object.message == other.message;\n\n    case regexpTag:\n    case stringTag:\n      // Coerce regexes to strings and treat strings, primitives and objects,\n      // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring\n      // for more details.\n      return object == (other + '');\n\n    case mapTag:\n      var convert = mapToArray;\n\n    case setTag:\n      var isPartial = bitmask & COMPARE_PARTIAL_FLAG;\n      convert || (convert = setToArray);\n\n      if (object.size != other.size && !isPartial) {\n        return false;\n      }\n      // Assume cyclic values are equal.\n      var stacked = stack.get(object);\n      if (stacked) {\n        return stacked == other;\n      }\n      bitmask |= COMPARE_UNORDERED_FLAG;\n\n      // Recursively compare objects (susceptible to call stack limits).\n      stack.set(object, other);\n      var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);\n      stack['delete'](object);\n      return result;\n\n    case symbolTag:\n      if (symbolValueOf) {\n        return symbolValueOf.call(object) == symbolValueOf.call(other);\n      }\n  }\n  return false;\n}\n\nmodule.exports = equalByTag;\n","var getAllKeys = require('./_getAllKeys');\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1;\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * A specialized version of `baseIsEqualDeep` for objects with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction equalObjects(object, other, bitmask, customizer, equalFunc, stack) {\n  var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n      objProps = getAllKeys(object),\n      objLength = objProps.length,\n      othProps = getAllKeys(other),\n      othLength = othProps.length;\n\n  if (objLength != othLength && !isPartial) {\n    return false;\n  }\n  var index = objLength;\n  while (index--) {\n    var key = objProps[index];\n    if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {\n      return false;\n    }\n  }\n  // Check that cyclic values are equal.\n  var objStacked = stack.get(object);\n  var othStacked = stack.get(other);\n  if (objStacked && othStacked) {\n    return objStacked == other && othStacked == object;\n  }\n  var result = true;\n  stack.set(object, other);\n  stack.set(other, object);\n\n  var skipCtor = isPartial;\n  while (++index < objLength) {\n    key = objProps[index];\n    var objValue = object[key],\n        othValue = other[key];\n\n    if (customizer) {\n      var compared = isPartial\n        ? customizer(othValue, objValue, key, other, object, stack)\n        : customizer(objValue, othValue, key, object, other, stack);\n    }\n    // Recursively compare objects (susceptible to call stack limits).\n    if (!(compared === undefined\n          ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))\n          : compared\n        )) {\n      result = false;\n      break;\n    }\n    skipCtor || (skipCtor = key == 'constructor');\n  }\n  if (result && !skipCtor) {\n    var objCtor = object.constructor,\n        othCtor = other.constructor;\n\n    // Non `Object` object instances with different constructors are not equal.\n    if (objCtor != othCtor &&\n        ('constructor' in object && 'constructor' in other) &&\n        !(typeof objCtor == 'function' && objCtor instanceof objCtor &&\n          typeof othCtor == 'function' && othCtor instanceof othCtor)) {\n      result = false;\n    }\n  }\n  stack['delete'](object);\n  stack['delete'](other);\n  return result;\n}\n\nmodule.exports = equalObjects;\n","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nmodule.exports = freeGlobal;\n","var baseGetAllKeys = require('./_baseGetAllKeys'),\n    getSymbols = require('./_getSymbols'),\n    keys = require('./keys');\n\n/**\n * Creates an array of own enumerable property names and symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction getAllKeys(object) {\n  return baseGetAllKeys(object, keys, getSymbols);\n}\n\nmodule.exports = getAllKeys;\n","var baseGetAllKeys = require('./_baseGetAllKeys'),\n    getSymbolsIn = require('./_getSymbolsIn'),\n    keysIn = require('./keysIn');\n\n/**\n * Creates an array of own and inherited enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction getAllKeysIn(object) {\n  return baseGetAllKeys(object, keysIn, getSymbolsIn);\n}\n\nmodule.exports = getAllKeysIn;\n","var isKeyable = require('./_isKeyable');\n\n/**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\nfunction getMapData(map, key) {\n  var data = map.__data__;\n  return isKeyable(key)\n    ? data[typeof key == 'string' ? 'string' : 'hash']\n    : data.map;\n}\n\nmodule.exports = getMapData;\n","var baseIsNative = require('./_baseIsNative'),\n    getValue = require('./_getValue');\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n  var value = getValue(object, key);\n  return baseIsNative(value) ? value : undefined;\n}\n\nmodule.exports = getNative;\n","var overArg = require('./_overArg');\n\n/** Built-in value references. */\nvar getPrototype = overArg(Object.getPrototypeOf, Object);\n\nmodule.exports = getPrototype;\n","var Symbol = require('./_Symbol');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\nmodule.exports = getRawTag;\n","var arrayFilter = require('./_arrayFilter'),\n    stubArray = require('./stubArray');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeGetSymbols = Object.getOwnPropertySymbols;\n\n/**\n * Creates an array of the own enumerable symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\nvar getSymbols = !nativeGetSymbols ? stubArray : function(object) {\n  if (object == null) {\n    return [];\n  }\n  object = Object(object);\n  return arrayFilter(nativeGetSymbols(object), function(symbol) {\n    return propertyIsEnumerable.call(object, symbol);\n  });\n};\n\nmodule.exports = getSymbols;\n","var arrayPush = require('./_arrayPush'),\n    getPrototype = require('./_getPrototype'),\n    getSymbols = require('./_getSymbols'),\n    stubArray = require('./stubArray');\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeGetSymbols = Object.getOwnPropertySymbols;\n\n/**\n * Creates an array of the own and inherited enumerable symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\nvar getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {\n  var result = [];\n  while (object) {\n    arrayPush(result, getSymbols(object));\n    object = getPrototype(object);\n  }\n  return result;\n};\n\nmodule.exports = getSymbolsIn;\n","var DataView = require('./_DataView'),\n    Map = require('./_Map'),\n    Promise = require('./_Promise'),\n    Set = require('./_Set'),\n    WeakMap = require('./_WeakMap'),\n    baseGetTag = require('./_baseGetTag'),\n    toSource = require('./_toSource');\n\n/** `Object#toString` result references. */\nvar mapTag = '[object Map]',\n    objectTag = '[object Object]',\n    promiseTag = '[object Promise]',\n    setTag = '[object Set]',\n    weakMapTag = '[object WeakMap]';\n\nvar dataViewTag = '[object DataView]';\n\n/** Used to detect maps, sets, and weakmaps. */\nvar dataViewCtorString = toSource(DataView),\n    mapCtorString = toSource(Map),\n    promiseCtorString = toSource(Promise),\n    setCtorString = toSource(Set),\n    weakMapCtorString = toSource(WeakMap);\n\n/**\n * Gets the `toStringTag` of `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nvar getTag = baseGetTag;\n\n// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.\nif ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||\n    (Map && getTag(new Map) != mapTag) ||\n    (Promise && getTag(Promise.resolve()) != promiseTag) ||\n    (Set && getTag(new Set) != setTag) ||\n    (WeakMap && getTag(new WeakMap) != weakMapTag)) {\n  getTag = function(value) {\n    var result = baseGetTag(value),\n        Ctor = result == objectTag ? value.constructor : undefined,\n        ctorString = Ctor ? toSource(Ctor) : '';\n\n    if (ctorString) {\n      switch (ctorString) {\n        case dataViewCtorString: return dataViewTag;\n        case mapCtorString: return mapTag;\n        case promiseCtorString: return promiseTag;\n        case setCtorString: return setTag;\n        case weakMapCtorString: return weakMapTag;\n      }\n    }\n    return result;\n  };\n}\n\nmodule.exports = getTag;\n","/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue(object, key) {\n  return object == null ? undefined : object[key];\n}\n\nmodule.exports = getValue;\n","var nativeCreate = require('./_nativeCreate');\n\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\nfunction hashClear() {\n  this.__data__ = nativeCreate ? nativeCreate(null) : {};\n  this.size = 0;\n}\n\nmodule.exports = hashClear;\n","/**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction hashDelete(key) {\n  var result = this.has(key) && delete this.__data__[key];\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\nmodule.exports = hashDelete;\n","var nativeCreate = require('./_nativeCreate');\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction hashGet(key) {\n  var data = this.__data__;\n  if (nativeCreate) {\n    var result = data[key];\n    return result === HASH_UNDEFINED ? undefined : result;\n  }\n  return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n\nmodule.exports = hashGet;\n","var nativeCreate = require('./_nativeCreate');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction hashHas(key) {\n  var data = this.__data__;\n  return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);\n}\n\nmodule.exports = hashHas;\n","var nativeCreate = require('./_nativeCreate');\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\nfunction hashSet(key, value) {\n  var data = this.__data__;\n  this.size += this.has(key) ? 0 : 1;\n  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n  return this;\n}\n\nmodule.exports = hashSet;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Initializes an array clone.\n *\n * @private\n * @param {Array} array The array to clone.\n * @returns {Array} Returns the initialized clone.\n */\nfunction initCloneArray(array) {\n  var length = array.length,\n      result = new array.constructor(length);\n\n  // Add properties assigned by `RegExp#exec`.\n  if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {\n    result.index = array.index;\n    result.input = array.input;\n  }\n  return result;\n}\n\nmodule.exports = initCloneArray;\n","var cloneArrayBuffer = require('./_cloneArrayBuffer'),\n    cloneDataView = require('./_cloneDataView'),\n    cloneRegExp = require('./_cloneRegExp'),\n    cloneSymbol = require('./_cloneSymbol'),\n    cloneTypedArray = require('./_cloneTypedArray');\n\n/** `Object#toString` result references. */\nvar boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    symbolTag = '[object Symbol]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]',\n    float32Tag = '[object Float32Array]',\n    float64Tag = '[object Float64Array]',\n    int8Tag = '[object Int8Array]',\n    int16Tag = '[object Int16Array]',\n    int32Tag = '[object Int32Array]',\n    uint8Tag = '[object Uint8Array]',\n    uint8ClampedTag = '[object Uint8ClampedArray]',\n    uint16Tag = '[object Uint16Array]',\n    uint32Tag = '[object Uint32Array]';\n\n/**\n * Initializes an object clone based on its `toStringTag`.\n *\n * **Note:** This function only supports cloning values with tags of\n * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`.\n *\n * @private\n * @param {Object} object The object to clone.\n * @param {string} tag The `toStringTag` of the object to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the initialized clone.\n */\nfunction initCloneByTag(object, tag, isDeep) {\n  var Ctor = object.constructor;\n  switch (tag) {\n    case arrayBufferTag:\n      return cloneArrayBuffer(object);\n\n    case boolTag:\n    case dateTag:\n      return new Ctor(+object);\n\n    case dataViewTag:\n      return cloneDataView(object, isDeep);\n\n    case float32Tag: case float64Tag:\n    case int8Tag: case int16Tag: case int32Tag:\n    case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:\n      return cloneTypedArray(object, isDeep);\n\n    case mapTag:\n      return new Ctor;\n\n    case numberTag:\n    case stringTag:\n      return new Ctor(object);\n\n    case regexpTag:\n      return cloneRegExp(object);\n\n    case setTag:\n      return new Ctor;\n\n    case symbolTag:\n      return cloneSymbol(object);\n  }\n}\n\nmodule.exports = initCloneByTag;\n","var baseCreate = require('./_baseCreate'),\n    getPrototype = require('./_getPrototype'),\n    isPrototype = require('./_isPrototype');\n\n/**\n * Initializes an object clone.\n *\n * @private\n * @param {Object} object The object to clone.\n * @returns {Object} Returns the initialized clone.\n */\nfunction initCloneObject(object) {\n  return (typeof object.constructor == 'function' && !isPrototype(object))\n    ? baseCreate(getPrototype(object))\n    : {};\n}\n\nmodule.exports = initCloneObject;\n","/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n  var type = typeof value;\n  length = length == null ? MAX_SAFE_INTEGER : length;\n\n  return !!length &&\n    (type == 'number' ||\n      (type != 'symbol' && reIsUint.test(value))) &&\n        (value > -1 && value % 1 == 0 && value < length);\n}\n\nmodule.exports = isIndex;\n","/**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\nfunction isKeyable(value) {\n  var type = typeof value;\n  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n    ? (value !== '__proto__')\n    : (value === null);\n}\n\nmodule.exports = isKeyable;\n","var coreJsData = require('./_coreJsData');\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = (function() {\n  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n  return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n  return !!maskSrcKey && (maskSrcKey in func);\n}\n\nmodule.exports = isMasked;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n  var Ctor = value && value.constructor,\n      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n  return value === proto;\n}\n\nmodule.exports = isPrototype;\n","/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\nfunction listCacheClear() {\n  this.__data__ = [];\n  this.size = 0;\n}\n\nmodule.exports = listCacheClear;\n","var assocIndexOf = require('./_assocIndexOf');\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype;\n\n/** Built-in value references. */\nvar splice = arrayProto.splice;\n\n/**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction listCacheDelete(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    return false;\n  }\n  var lastIndex = data.length - 1;\n  if (index == lastIndex) {\n    data.pop();\n  } else {\n    splice.call(data, index, 1);\n  }\n  --this.size;\n  return true;\n}\n\nmodule.exports = listCacheDelete;\n","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction listCacheGet(key) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  return index < 0 ? undefined : data[index][1];\n}\n\nmodule.exports = listCacheGet;\n","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction listCacheHas(key) {\n  return assocIndexOf(this.__data__, key) > -1;\n}\n\nmodule.exports = listCacheHas;\n","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\nfunction listCacheSet(key, value) {\n  var data = this.__data__,\n      index = assocIndexOf(data, key);\n\n  if (index < 0) {\n    ++this.size;\n    data.push([key, value]);\n  } else {\n    data[index][1] = value;\n  }\n  return this;\n}\n\nmodule.exports = listCacheSet;\n","var Hash = require('./_Hash'),\n    ListCache = require('./_ListCache'),\n    Map = require('./_Map');\n\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\nfunction mapCacheClear() {\n  this.size = 0;\n  this.__data__ = {\n    'hash': new Hash,\n    'map': new (Map || ListCache),\n    'string': new Hash\n  };\n}\n\nmodule.exports = mapCacheClear;\n","var getMapData = require('./_getMapData');\n\n/**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction mapCacheDelete(key) {\n  var result = getMapData(this, key)['delete'](key);\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\nmodule.exports = mapCacheDelete;\n","var getMapData = require('./_getMapData');\n\n/**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction mapCacheGet(key) {\n  return getMapData(this, key).get(key);\n}\n\nmodule.exports = mapCacheGet;\n","var getMapData = require('./_getMapData');\n\n/**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction mapCacheHas(key) {\n  return getMapData(this, key).has(key);\n}\n\nmodule.exports = mapCacheHas;\n","var getMapData = require('./_getMapData');\n\n/**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\nfunction mapCacheSet(key, value) {\n  var data = getMapData(this, key),\n      size = data.size;\n\n  data.set(key, value);\n  this.size += data.size == size ? 0 : 1;\n  return this;\n}\n\nmodule.exports = mapCacheSet;\n","/**\n * Converts `map` to its key-value pairs.\n *\n * @private\n * @param {Object} map The map to convert.\n * @returns {Array} Returns the key-value pairs.\n */\nfunction mapToArray(map) {\n  var index = -1,\n      result = Array(map.size);\n\n  map.forEach(function(value, key) {\n    result[++index] = [key, value];\n  });\n  return result;\n}\n\nmodule.exports = mapToArray;\n","var getNative = require('./_getNative');\n\n/* Built-in method references that are verified to be native. */\nvar nativeCreate = getNative(Object, 'create');\n\nmodule.exports = nativeCreate;\n","var overArg = require('./_overArg');\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeKeys = overArg(Object.keys, Object);\n\nmodule.exports = nativeKeys;\n","/**\n * This function is like\n * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * except that it includes inherited enumerable properties.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction nativeKeysIn(object) {\n  var result = [];\n  if (object != null) {\n    for (var key in Object(object)) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nmodule.exports = nativeKeysIn;\n","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Detect free variable `process` from Node.js. */\nvar freeProcess = moduleExports && freeGlobal.process;\n\n/** Used to access faster Node.js helpers. */\nvar nodeUtil = (function() {\n  try {\n    // Use `util.types` for Node.js 10+.\n    var types = freeModule && freeModule.require && freeModule.require('util').types;\n\n    if (types) {\n      return types;\n    }\n\n    // Legacy `process.binding('util')` for Node.js < 10.\n    return freeProcess && freeProcess.binding && freeProcess.binding('util');\n  } catch (e) {}\n}());\n\nmodule.exports = nodeUtil;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n\nmodule.exports = objectToString;\n","/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n  return function(arg) {\n    return func(transform(arg));\n  };\n}\n\nmodule.exports = overArg;\n","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nmodule.exports = root;\n","/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/**\n * Adds `value` to the array cache.\n *\n * @private\n * @name add\n * @memberOf SetCache\n * @alias push\n * @param {*} value The value to cache.\n * @returns {Object} Returns the cache instance.\n */\nfunction setCacheAdd(value) {\n  this.__data__.set(value, HASH_UNDEFINED);\n  return this;\n}\n\nmodule.exports = setCacheAdd;\n","/**\n * Checks if `value` is in the array cache.\n *\n * @private\n * @name has\n * @memberOf SetCache\n * @param {*} value The value to search for.\n * @returns {number} Returns `true` if `value` is found, else `false`.\n */\nfunction setCacheHas(value) {\n  return this.__data__.has(value);\n}\n\nmodule.exports = setCacheHas;\n","/**\n * Converts `set` to an array of its values.\n *\n * @private\n * @param {Object} set The set to convert.\n * @returns {Array} Returns the values.\n */\nfunction setToArray(set) {\n  var index = -1,\n      result = Array(set.size);\n\n  set.forEach(function(value) {\n    result[++index] = value;\n  });\n  return result;\n}\n\nmodule.exports = setToArray;\n","var ListCache = require('./_ListCache');\n\n/**\n * Removes all key-value entries from the stack.\n *\n * @private\n * @name clear\n * @memberOf Stack\n */\nfunction stackClear() {\n  this.__data__ = new ListCache;\n  this.size = 0;\n}\n\nmodule.exports = stackClear;\n","/**\n * Removes `key` and its value from the stack.\n *\n * @private\n * @name delete\n * @memberOf Stack\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction stackDelete(key) {\n  var data = this.__data__,\n      result = data['delete'](key);\n\n  this.size = data.size;\n  return result;\n}\n\nmodule.exports = stackDelete;\n","/**\n * Gets the stack value for `key`.\n *\n * @private\n * @name get\n * @memberOf Stack\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction stackGet(key) {\n  return this.__data__.get(key);\n}\n\nmodule.exports = stackGet;\n","/**\n * Checks if a stack value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Stack\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction stackHas(key) {\n  return this.__data__.has(key);\n}\n\nmodule.exports = stackHas;\n","var ListCache = require('./_ListCache'),\n    Map = require('./_Map'),\n    MapCache = require('./_MapCache');\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/**\n * Sets the stack `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Stack\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the stack cache instance.\n */\nfunction stackSet(key, value) {\n  var data = this.__data__;\n  if (data instanceof ListCache) {\n    var pairs = data.__data__;\n    if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n      pairs.push([key, value]);\n      this.size = ++data.size;\n      return this;\n    }\n    data = this.__data__ = new MapCache(pairs);\n  }\n  data.set(key, value);\n  this.size = data.size;\n  return this;\n}\n\nmodule.exports = stackSet;\n","/** Used for built-in method references. */\nvar funcProto = Function.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to convert.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n  if (func != null) {\n    try {\n      return funcToString.call(func);\n    } catch (e) {}\n    try {\n      return (func + '');\n    } catch (e) {}\n  }\n  return '';\n}\n\nmodule.exports = toSource;\n","var baseClone = require('./_baseClone');\n\n/** Used to compose bitmasks for cloning. */\nvar CLONE_DEEP_FLAG = 1,\n    CLONE_SYMBOLS_FLAG = 4;\n\n/**\n * This method is like `_.clone` except that it recursively clones `value`.\n *\n * @static\n * @memberOf _\n * @since 1.0.0\n * @category Lang\n * @param {*} value The value to recursively clone.\n * @returns {*} Returns the deep cloned value.\n * @see _.clone\n * @example\n *\n * var objects = [{ 'a': 1 }, { 'b': 2 }];\n *\n * var deep = _.cloneDeep(objects);\n * console.log(deep[0] === objects[0]);\n * // => false\n */\nfunction cloneDeep(value) {\n  return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);\n}\n\nmodule.exports = cloneDeep;\n","/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n  return value === other || (value !== value && other !== other);\n}\n\nmodule.exports = eq;\n","var baseIsArguments = require('./_baseIsArguments'),\n    isObjectLike = require('./isObjectLike');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n *  else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nvar isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\n  return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&\n    !propertyIsEnumerable.call(value, 'callee');\n};\n\nmodule.exports = isArguments;\n","/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\nmodule.exports = isArray;\n","var isFunction = require('./isFunction'),\n    isLength = require('./isLength');\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n  return value != null && isLength(value.length) && !isFunction(value);\n}\n\nmodule.exports = isArrayLike;\n","var root = require('./_root'),\n    stubFalse = require('./stubFalse');\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;\n\n/**\n * Checks if `value` is a buffer.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n *\n * _.isBuffer(new Buffer(2));\n * // => true\n *\n * _.isBuffer(new Uint8Array(2));\n * // => false\n */\nvar isBuffer = nativeIsBuffer || stubFalse;\n\nmodule.exports = isBuffer;\n","var baseIsEqual = require('./_baseIsEqual');\n\n/**\n * Performs a deep comparison between two values to determine if they are\n * equivalent.\n *\n * **Note:** This method supports comparing arrays, array buffers, booleans,\n * date objects, error objects, maps, numbers, `Object` objects, regexes,\n * sets, strings, symbols, and typed arrays. `Object` objects are compared\n * by their own, not inherited, enumerable properties. Functions and DOM\n * nodes are compared by strict equality, i.e. `===`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.isEqual(object, other);\n * // => true\n *\n * object === other;\n * // => false\n */\nfunction isEqual(value, other) {\n  return baseIsEqual(value, other);\n}\n\nmodule.exports = isEqual;\n","var baseGetTag = require('./_baseGetTag'),\n    isObject = require('./isObject');\n\n/** `Object#toString` result references. */\nvar asyncTag = '[object AsyncFunction]',\n    funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]',\n    proxyTag = '[object Proxy]';\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  if (!isObject(value)) {\n    return false;\n  }\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 9 which returns 'object' for typed arrays and other constructors.\n  var tag = baseGetTag(value);\n  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n}\n\nmodule.exports = isFunction;\n","/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n  return typeof value == 'number' &&\n    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\nmodule.exports = isLength;\n","var baseIsMap = require('./_baseIsMap'),\n    baseUnary = require('./_baseUnary'),\n    nodeUtil = require('./_nodeUtil');\n\n/* Node.js helper references. */\nvar nodeIsMap = nodeUtil && nodeUtil.isMap;\n\n/**\n * Checks if `value` is classified as a `Map` object.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a map, else `false`.\n * @example\n *\n * _.isMap(new Map);\n * // => true\n *\n * _.isMap(new WeakMap);\n * // => false\n */\nvar isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;\n\nmodule.exports = isMap;\n","/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return value != null && (type == 'object' || type == 'function');\n}\n\nmodule.exports = isObject;\n","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\nmodule.exports = isObjectLike;\n","var baseIsSet = require('./_baseIsSet'),\n    baseUnary = require('./_baseUnary'),\n    nodeUtil = require('./_nodeUtil');\n\n/* Node.js helper references. */\nvar nodeIsSet = nodeUtil && nodeUtil.isSet;\n\n/**\n * Checks if `value` is classified as a `Set` object.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a set, else `false`.\n * @example\n *\n * _.isSet(new Set);\n * // => true\n *\n * _.isSet(new WeakSet);\n * // => false\n */\nvar isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;\n\nmodule.exports = isSet;\n","var baseIsTypedArray = require('./_baseIsTypedArray'),\n    baseUnary = require('./_baseUnary'),\n    nodeUtil = require('./_nodeUtil');\n\n/* Node.js helper references. */\nvar nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n\n/**\n * Checks if `value` is classified as a typed array.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n * @example\n *\n * _.isTypedArray(new Uint8Array);\n * // => true\n *\n * _.isTypedArray([]);\n * // => false\n */\nvar isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\nmodule.exports = isTypedArray;\n","var arrayLikeKeys = require('./_arrayLikeKeys'),\n    baseKeys = require('./_baseKeys'),\n    isArrayLike = require('./isArrayLike');\n\n/**\n * Creates an array of the own enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * for more details.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keys(new Foo);\n * // => ['a', 'b'] (iteration order is not guaranteed)\n *\n * _.keys('hi');\n * // => ['0', '1']\n */\nfunction keys(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n}\n\nmodule.exports = keys;\n","var arrayLikeKeys = require('./_arrayLikeKeys'),\n    baseKeysIn = require('./_baseKeysIn'),\n    isArrayLike = require('./isArrayLike');\n\n/**\n * Creates an array of the own and inherited enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keysIn(new Foo);\n * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n */\nfunction keysIn(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);\n}\n\nmodule.exports = keysIn;\n","/**\n * This method returns a new empty array.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {Array} Returns the new empty array.\n * @example\n *\n * var arrays = _.times(2, _.stubArray);\n *\n * console.log(arrays);\n * // => [[], []]\n *\n * console.log(arrays[0] === arrays[1]);\n * // => false\n */\nfunction stubArray() {\n  return [];\n}\n\nmodule.exports = stubArray;\n","/**\n * This method returns `false`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n *\n * _.times(2, _.stubFalse);\n * // => [false, false]\n */\nfunction stubFalse() {\n  return false;\n}\n\nmodule.exports = stubFalse;\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\tid: moduleId,\n\t\tloaded: false,\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Flag the module as loaded\n\tmodule.loaded = true;\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","__webpack_require__.nmd = (module) => {\n\tmodule.paths = [];\n\tif (!module.children) module.children = [];\n\treturn module;\n};","import type OpenFin from \"@openfin/core\";\nimport { fin } from \"@openfin/core\";\n\nlet fileName: string;\nlet debugLogStr: string;\nlet debugLogFile: File;\nlet opfsLogFile: File;\nconst channelName = `${fin.me.identity.uuid}-logger`;\nlet channelClient: OpenFin.ChannelClient;\nlet channelProvider: OpenFin.ChannelProvider;\nlet fileHandle: FileSystemFileHandle;\n\nwindow.addEventListener(\"DOMContentLoaded\", async () => {\n\tconst platform: OpenFin.Platform = fin.Platform.getCurrentSync();\n\tawait platform.once(\"platform-api-ready\", async () => init());\n\tfin.Platform.init({\n\t\toverrideCallback: async (Provider) => {\n\t\t\t/**\n\t\t\t * Override the provider class.\n\t\t\t */\n\t\t\tclass Override extends Provider {}\n\t\t\treturn new Override();\n\t\t}\n\t}).catch(() => {});\n});\n\n/**\n * Populates DOM with the UI elements and adds listeners obtaining selected/submitted options.\n */\nasync function init(): Promise<void> {\n\tconst logListElement = document.querySelector<HTMLSelectElement>(\"#log-list\");\n\tif (logListElement) {\n\t\tawait createLogDropDown(logListElement);\n\t\tlogListElement.addEventListener(\"change\", async (selectionChangeEvent) => {\n\t\t\tfileName = (selectionChangeEvent.target as HTMLOptionElement).value;\n\t\t});\n\t}\n\n\tconst upload = document.querySelector<HTMLFormElement>(\"#upload-form\");\n\tif (upload) {\n\t\tupload.addEventListener(\"submit\", uploadHandler);\n\t}\n\n\tconst sendAppLogBtn = document.querySelector<HTMLButtonElement>(\"#send-app-log\");\n\tif (sendAppLogBtn) {\n\t\tsendAppLogBtn.addEventListener(\"click\", sendApplicationLogs);\n\t}\n\n\tconst sendOPFSLogBtn = document.querySelector<HTMLButtonElement>(\"#send-opfs-log\");\n\tif (sendOPFSLogBtn) {\n\t\tsendOPFSLogBtn.addEventListener(\"click\", sendOPFSLogs);\n\t}\n\n\tconst consoleLogBtn = document.querySelector<HTMLButtonElement>(\"#console-app-log\");\n\tif (consoleLogBtn) {\n\t\tconsoleLogBtn.addEventListener(\"click\", consoleLogMessage);\n\t}\n\n\tconst channelLogBtn = document.querySelector<HTMLButtonElement>(\"#channel-app-log\");\n\tif (channelLogBtn) {\n\t\tchannelLogBtn.addEventListener(\"click\", channelLogMessage);\n\t}\n\n\tconst clearPreviewBtn = document.querySelector<HTMLButtonElement>(\"#clear-preview\");\n\tif (clearPreviewBtn) {\n\t\tclearPreviewBtn.addEventListener(\"click\", clearPreview);\n\t}\n\n\tawait setupChannelClientAndService();\n}\n\n/**\n * Sets up the Channel Client and Service.\n */\nasync function setupChannelClientAndService(): Promise<void> {\n\t// if your content is coming from the same domain then you would not need to use the Channel API and can consider alternatives\n\t// such as BroadcastChannel API or SharedWorker\n\tif (channelClient === undefined && channelProvider === undefined) {\n\t\t// set up the file handler for logging for the service\n\t\tif (fileHandle === undefined) {\n\t\t\tconst root = await navigator.storage.getDirectory();\n\t\t\t// Create a new file handle.\n\t\t\t// The name could be date based if you were going to create a new file each day.\n\t\t\tfileHandle = await root.getFileHandle(\"log.log\", { create: true });\n\t\t}\n\t\tchannelProvider = await fin.InterApplicationBus.Channel.create(channelName);\n\t\tchannelProvider.onConnection((identity, payload) => {\n\t\t\tif (identity.uuid !== fin.me.identity.uuid) {\n\t\t\t\t// reject connection\n\t\t\t\tthrow new Error(\"Connection rejected. Only the current application can connect to the channel.\");\n\t\t\t}\n\t\t\t// you can add additional logic to validate the view/window connecting (e.g. to ensure it is only trusted urls that are allowed to log etc)\n\t\t});\n\t\tchannelProvider.register(\"log\", async (payload: unknown, identity) => {\n\t\t\tif (identity.uuid !== fin.me.identity.uuid) {\n\t\t\t\t// reject request to log (this is optional but you might have multiple actions registered and you might allow a connection to the service but not all actions)\n\t\t\t\tthrow new Error(\"Log request rejected. Only the current application can log.\");\n\t\t\t}\n\t\t\tconst logPreview = document.querySelector(\"#preview\");\n\t\t\ttry {\n\t\t\t\t// you could make this more complex to support log levels etc. For now we just pass a string to the log function\n\t\t\t\t// utc timestamp\n\t\t\t\tconst utcTimestamp = new Date().toISOString();\n\t\t\t\tconst message = `${utcTimestamp}|${identity.name}|${payload}`;\n\t\t\t\tawait writeLogToFile(message);\n\t\t\t\tif (logPreview) {\n\t\t\t\t\tlogPreview.textContent += `\nConsole Logged the following message through Channel API: \n\"${message}\"`;\n\t\t\t\t}\n\t\t\t} catch (err: unknown) {\n\t\t\t\tif (logPreview) {\n\t\t\t\t\tlogPreview.textContent += `\nError console logging message through Channel API: ${(err as Error).message}`;\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t\tchannelClient = await fin.InterApplicationBus.Channel.connect(channelName);\n\t}\n}\n\n/**\n * Write logs to file. This logic could be done in a worker to avoid blocking the main thread.\n * https://developer.mozilla.org/en-US/docs/Web/API/File_System_API/Origin_private_file_system.\n * @param logMessage The log message to write to file.\n */\nasync function writeLogToFile(logMessage: string): Promise<void> {\n\ttry {\n\t\tif (fileHandle === undefined) {\n\t\t\tconst root = await navigator.storage.getDirectory();\n\t\t\t// Create a new file handle if it doesn't exist.\n\t\t\t// The name could be date based if you were going to create a new file each day.\n\t\t\tfileHandle = await root.getFileHandle(\"log.log\", { create: true });\n\t\t}\n\t\t// Create a writable stream\n\t\tconst writableStream = await fileHandle.createWritable({ keepExistingData: true });\n\n\t\t// Move the write position to the end of the file\n\t\tconst fileForSize = await fileHandle.getFile();\n\t\tconst size = fileForSize.size;\n\t\tawait writableStream.seek(size);\n\n\t\t// Write the log message to the file\n\t\tif (size === 0) {\n\t\t\tawait writableStream.write(logMessage);\n\t\t} else {\n\t\t\tawait writableStream.write(`\\n${logMessage}`);\n\t\t}\n\n\t\t// Close the file\n\t\tawait writableStream.close();\n\n\t\tconsole.log(\"Log written to file successfully.\");\n\t} catch (err) {\n\t\tconsole.error(\"Error writing log to file:\", err);\n\t}\n}\n\n/**\n * Handle uploads.\n * 1. Creates a FormData object.\n * 2. Creates a File object from the string of the Runtime debug log file contents.\n * 3. Populates the FormData object with necessary parameters to be read by the server.\n * 4. Uploads the created runtime debug log file to a server endpoint.\n * @param submitEvent The event to handle.\n */\nasync function uploadHandler(submitEvent: Event): Promise<void> {\n\tsubmitEvent.preventDefault();\n\tif (!fileName) {\n\t\tfileName = \"debug.log\";\n\t}\n\tconst formData = new FormData();\n\tdebugLogStr = await getLogFromName(fileName);\n\tdebugLogFile = new File([debugLogStr], fileName, { type: \"text/plain\" });\n\tformData.append(\"file\", debugLogFile);\n\tformData.append(\"filename\", fileName);\n\tformData.append(\"uuid\", fin.me.uuid);\n\tconst logPreview = document.querySelector(\"#preview\");\n\n\ttry {\n\t\tconst uploadState = await fetch(\"http://localhost:5050/uploads\", {\n\t\t\tmethod: \"POST\",\n\t\t\tbody: formData\n\t\t});\n\t\tconst uploadStateJson = await uploadState.json();\n\t\tconst uploadStateJsonString = JSON.stringify(uploadStateJson, null, 5);\n\t\tconst logs = `${new Date().toLocaleTimeString()}: ${uploadStateJsonString}\\n`;\n\t\tif (logPreview) {\n\t\t\tlogPreview.textContent += logs;\n\t\t}\n\t} catch (err: unknown) {\n\t\tif (logPreview) {\n\t\t\tlogPreview.textContent += `\nError uploading Runtime Logs: ${(err as Error).message}`;\n\t\t}\n\t}\n}\n\n/**\n * Uploads the OPFS log file to the server.\n * @returns true if the log file was uploaded successfully, false otherwise.\n */\nasync function uploadOPFSLogHandler(): Promise<boolean> {\n\t// read the log file from origin private file system\n\tif (fileHandle !== undefined) {\n\t\ttry {\n\t\t\t// read the file from fileHanlde\n\t\t\tconst file = await fileHandle.getFile();\n\t\t\tconst logFileName = file.name;\n\t\t\tconst fileContents = await file.text();\n\t\t\topfsLogFile = new File([fileContents], logFileName, { type: \"text/plain\" });\n\t\t\tconst opfsFormData = new FormData();\n\t\t\topfsFormData.append(\"opfsFile\", opfsLogFile);\n\t\t\topfsFormData.append(\"filename\", logFileName);\n\t\t\topfsFormData.append(\"uuid\", fin.me.uuid);\n\t\t\tconst result = await fetch(\"http://localhost:5050/opfsuploads\", {\n\t\t\t\tmethod: \"POST\",\n\t\t\t\tbody: opfsFormData\n\t\t\t});\n\t\t\tif (result.ok) {\n\t\t\t\t// Clear the log file after uploading\n\t\t\t\tconst writableStream = await fileHandle.createWritable();\n\t\t\t\tawait writableStream.truncate(0);\n\t\t\t\tawait writableStream.close();\n\n\t\t\t\tconst logPreview = document.querySelector(\"#preview\");\n\t\t\t\tconst uploadStateJson = await result.json();\n\t\t\t\tconst uploadStateJsonString = JSON.stringify(uploadStateJson, null, 5);\n\t\t\t\tconst logs = `${new Date().toLocaleTimeString()}: ${uploadStateJsonString}\\n`;\n\t\t\t\tif (logPreview) {\n\t\t\t\t\tlogPreview.textContent += logs;\n\t\t\t\t}\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\treturn false;\n\t\t} catch (error) {\n\t\t\tconsole.error(\"Error reading log file:\", error);\n\t\t\treturn false;\n\t\t}\n\t}\n\treturn false;\n}\n\n/**\n * Clears the preview log.\n */\nfunction clearPreview(): void {\n\tconst logPreview = document.querySelector(\"#preview\");\n\tif (logPreview) {\n\t\tlogPreview.textContent = \"\";\n\t}\n}\n\n/**\n * Sends a message to the OpenFin RVM to send the application logs.\n */\nasync function sendApplicationLogs(): Promise<void> {\n\tconst logPreview = document.querySelector(\"#preview\");\n\ttry {\n\t\tconst appLogResponse = await fin.Application.getCurrentSync().sendApplicationLog();\n\t\tif (logPreview) {\n\t\t\tlogPreview.textContent += `\nUploaded App Logs. Log ID: ${appLogResponse.logId}`;\n\t\t}\n\t} catch (err: unknown) {\n\t\tif (logPreview) {\n\t\t\tlogPreview.textContent += `\nError uploading App Logs: ${(err as Error).message}`;\n\t\t}\n\t}\n}\n\n/**\n * Sends opfs logs to the server.\n */\nasync function sendOPFSLogs(): Promise<void> {\n\tconst logPreview = document.querySelector(\"#preview\");\n\ttry {\n\t\tconst success = await uploadOPFSLogHandler();\n\t\tif (logPreview) {\n\t\t\tlogPreview.textContent += `\nUploaded OPFS Logs. Success: ${success}`;\n\t\t}\n\t} catch (err: unknown) {\n\t\tif (logPreview) {\n\t\t\tlogPreview.textContent += `\nError uploading OPFS Logs: ${(err as Error).message}`;\n\t\t}\n\t}\n}\n\n/**\n * Sends a message to console log.\n */\nasync function consoleLogMessage(): Promise<void> {\n\tconst logPreview = document.querySelector(\"#preview\");\n\ttry {\n\t\tconst message = `\nSending console log message: ${Date.now()}`;\n\t\tconsole.log(message);\n\t\tif (logPreview) {\n\t\t\tlogPreview.textContent += `\nConsole Logged the following message: \n\"${message}\"`;\n\t\t}\n\t} catch (err: unknown) {\n\t\tif (logPreview) {\n\t\t\tlogPreview.textContent += `\nError console logging message: ${(err as Error).message}`;\n\t\t}\n\t}\n}\n\n/**\n * Sends a message to console log through the Channel API.\n */\nasync function channelLogMessage(): Promise<void> {\n\tconst logPreview = document.querySelector(\"#preview\");\n\ttry {\n\t\tconst message = `\nSending channel log message: ${Date.now()}`;\n\t\tif (logPreview) {\n\t\t\tlogPreview.textContent += `\nSending the following message through the Channel API: \n\"${message}\"`;\n\t\t}\n\t\tawait channelClient.dispatch(\"log\", message);\n\t} catch (err: unknown) {\n\t\tif (logPreview) {\n\t\t\tlogPreview.textContent += `\nError sending message through Channel API: ${(err as Error).message}`;\n\t\t}\n\t}\n}\n\n/**\n * Retrieves the runtime debug log from a filename.\n * @param name file name of the runtime debug log to retrieve.\n * @returns the log content.\n */\nasync function getLogFromName(name: string): Promise<string> {\n\tconst log = await fin.System.getLog({ name });\n\treturn log;\n}\n\n/**\n * Creates an HTMLOptionElement for each of the Runtime debug logs.\n * @param parentElement HTML Element to append the log filename HTMLOptionElement to.\n */\nasync function createLogDropDown(parentElement: HTMLSelectElement): Promise<void> {\n\tconst logList: OpenFin.LogInfo[] = await fin.System.getLogList();\n\n\tfor (const log of logList) {\n\t\tconst logElement: HTMLOptionElement = document.createElement(\"option\");\n\t\tlogElement.id = log.date;\n\t\tlogElement.textContent = log.name;\n\t\tlogElement.value = log.name;\n\t\tparentElement.append(logElement);\n\t}\n}\n"],"names":[],"sourceRoot":""}
\ No newline at end of file
diff --git a/dev/john/update-logging-example/use-logging-apis/manifest.fin.json b/dev/john/update-logging-example/use-logging-apis/manifest.fin.json
index b4c82b3c..5577a918 100644
--- a/dev/john/update-logging-example/use-logging-apis/manifest.fin.json
+++ b/dev/john/update-logging-example/use-logging-apis/manifest.fin.json
@@ -1,14 +1,14 @@
 {
 	"runtime": {
-		"arguments": "--v=1 --inspect",
+		"arguments": "--enable-mesh --security-realm=workspace-platform-starter",
 		"version": "38.126.83.79"
 	},
-	"licenseKey": "64605fac-add3-48a0-8710-64b38e96a2dd",
-	"startup_app": {
+	"licenseKey": "openfin-demo-license-key",
+	"platform": {
 		"name": "use-application-logging",
 		"uuid": "use-application-logging",
 		"description": "An example of using application logging",
-		"url": "https://built-on-openfin.github.io/container-starter/dev/john/update-logging-example/use-logging-apis/html/app.html",
+		"providerUrl": "https://built-on-openfin.github.io/container-starter/dev/john/update-logging-example/use-logging-apis/html/provider.html",
 		"icon": "https://built-on-openfin.github.io/container-starter/dev/john/update-logging-example/use-logging-apis/favicon.ico",
 		"autoShow": true,
 		"defaultWidth": 1200,
@@ -16,10 +16,49 @@
 		"defaultCentered": true,
 		"minWidth": 800,
 		"minHeight": 400,
+		"appLogsTimezone": "utc",
 		"enableAppLogging": true,
 		"logManagement": {
 			"enabled": true,
 			"url": "https://built-on-openfin.github.io/container-starter/dev/john/update-logging-example/use-logging-apis"
 		}
+	},
+	"snapshot": {
+		"windows": [
+			{
+				"defaultHeight": 900,
+				"defaultWidth": 1200,
+				"defaultCentered": true,
+				"layout": {
+					"content": [
+						{
+							"type": "row",
+							"content": [
+								{
+									"type": "component",
+									"componentName": "view",
+									"componentState": {
+										"url": "https://built-on-openfin.github.io/container-starter/dev/john/update-logging-example/use-logging-apis/html/app.html"
+									}
+								},
+								{
+									"type": "component",
+									"componentName": "view",
+									"componentState": {
+										"url": "https://built-on-openfin.github.io/container-starter/dev/john/update-logging-example/use-logging-apis/html/app.html"
+									}
+								}
+							]
+						}
+					]
+				}
+			}
+		]
+	},
+	"supportInformation": {
+		"company": "OpenFin",
+		"product": "Container Logging APIs Example",
+		"email": "support@openfin.co",
+		"forwardErrorReports": false
 	}
 }
diff --git a/dev/john/update-logging-example/use-logging-apis/uploads/applogs/AppLogs.md b/dev/john/update-logging-example/use-logging-apis/uploads/applogs/AppLogs.md
new file mode 100644
index 00000000..bb829f14
--- /dev/null
+++ b/dev/john/update-logging-example/use-logging-apis/uploads/applogs/AppLogs.md
@@ -0,0 +1,4 @@
+# App Logs
+
+This directory will be written to by our example node server. It will receive the app log files that are sent to the server by the RVM.
+The file will be a zip and it will contain the app.log file which has the combined data from all web pages writing to the console.
diff --git a/dev/john/update-logging-example/use-logging-apis/uploads/opfslogs/OPFSLogs.md b/dev/john/update-logging-example/use-logging-apis/uploads/opfslogs/OPFSLogs.md
new file mode 100644
index 00000000..5541146f
--- /dev/null
+++ b/dev/john/update-logging-example/use-logging-apis/uploads/opfslogs/OPFSLogs.md
@@ -0,0 +1,3 @@
+# OPFS Logs
+
+This directory will be written to by our example node server. It will receive the log file that was written to by the provider. The provider gets messages from multiple views and itself and writes them to a log file in the origin private filesystem. The sample app then lets you get the contents of that log file to send to the server, write to this directory and clear.
diff --git a/dev/john/update-logging-example/use-logging-apis/uploads/runtimelogs/SystemLogs.md b/dev/john/update-logging-example/use-logging-apis/uploads/runtimelogs/SystemLogs.md
new file mode 100644
index 00000000..eca9f13c
--- /dev/null
+++ b/dev/john/update-logging-example/use-logging-apis/uploads/runtimelogs/SystemLogs.md
@@ -0,0 +1,3 @@
+# System Logs
+
+This directory will be written to by our example node server. It will receive the debug log file that contains runtime messages as well as other data and it will write it to this directory.