@shadr/iterm2-ts 0.1.0

package/dist/index.js

@@ -0,0 +1,852 @@
+import { create, toBinary, fromBinary } from '@bufbuild/protobuf';
+import { execFileSync } from 'child_process';
+import net from 'net';
+import WebSocket from 'ws';
+import { messageDesc, fileDesc } from '@bufbuild/protobuf/codegenv2';
+import { existsSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+
+// src/api/client.ts
+var cookieArgs = () => ["-e", 'tell application "iTerm2" to request cookie'];
+var cookieAndKeyArgs = (name) => [
+  "-e",
+  `tell application "iTerm2" to request cookie and key for app named "${name}"`
+];
+var getAuthCredentials = (appName = "iterm2-ts") => {
+  const envCookie = process.env.ITERM2_COOKIE;
+  if (envCookie) {
+    const envKey = process.env.ITERM2_KEY;
+    return { cookie: envCookie, key: envKey ?? void 0 };
+  }
+  try {
+    const result = execFileSync("osascript", cookieAndKeyArgs(appName), {
+      encoding: "utf-8",
+      timeout: 5e3
+    }).trim();
+    const parts = result.split(" ");
+    const cookie = parts[0];
+    const key = parts[1];
+    if (!cookie) {
+      throw new Error("Empty cookie from osascript");
+    }
+    return { cookie, key: key || void 0 };
+  } catch {
+    try {
+      const cookie = execFileSync("osascript", cookieArgs(), {
+        encoding: "utf-8",
+        timeout: 5e3
+      }).trim();
+      if (!cookie) {
+        throw new Error("Empty cookie from osascript");
+      }
+      return { cookie };
+    } catch (err) {
+      throw new Error(
+        `Failed to get iTerm2 auth credentials. Ensure iTerm2 is running and "Enable Python API" is on in Preferences > General > Magic. ${err}`
+      );
+    }
+  }
+};
+var buildHeaders = (advisoryName, disableAuthUi = false) => {
+  const creds = getAuthCredentials(advisoryName);
+  return {
+    origin: "ws://localhost",
+    "x-iterm2-library-version": "typescript 0.1.0",
+    "x-iterm2-disable-auth-ui": disableAuthUi ? "1" : "0",
+    "x-iterm2-advisory-name": advisoryName,
+    ...creds.cookie ? { "x-iterm2-cookie": creds.cookie } : {},
+    ...creds.key ? { "x-iterm2-key": creds.key } : {}
+  };
+};
+var file_api = /* @__PURE__ */ fileDesc("CglhcGkucHJvdG8SBml0ZXJtMiLZEAoXQ2xpZW50T3JpZ2luYXRlZE1lc3NhZ2USCgoCaWQYASABKAMSNgoSZ2V0X2J1ZmZlcl9yZXF1ZXN0GGQgASgLMhguaXRlcm0yLkdldEJ1ZmZlclJlcXVlc3RIABI2ChJnZXRfcHJvbXB0X3JlcXVlc3QYZSABKAsyGC5pdGVybTIuR2V0UHJvbXB0UmVxdWVzdEgAEjkKE3RyYW5zYWN0aW9uX3JlcXVlc3QYZiABKAsyGi5pdGVybTIuVHJhbnNhY3Rpb25SZXF1ZXN0SAASOwoUbm90aWZpY2F0aW9uX3JlcXVlc3QYZyABKAsyGy5pdGVybTIuTm90aWZpY2F0aW9uUmVxdWVzdEgAEjwKFXJlZ2lzdGVyX3Rvb2xfcmVxdWVzdBhoIAEoCzIbLml0ZXJtMi5SZWdpc3RlclRvb2xSZXF1ZXN0SAASSQocc2V0X3Byb2ZpbGVfcHJvcGVydHlfcmVxdWVzdBhpIAEoCzIhLml0ZXJtMi5TZXRQcm9maWxlUHJvcGVydHlSZXF1ZXN0SAASPAoVbGlzdF9zZXNzaW9uc19yZXF1ZXN0GGogASgLMhsuaXRlcm0yLkxpc3RTZXNzaW9uc1JlcXVlc3RIABI0ChFzZW5kX3RleHRfcmVxdWVzdBhrIAEoCzIXLml0ZXJtMi5TZW5kVGV4dFJlcXVlc3RIABI2ChJjcmVhdGVfdGFiX3JlcXVlc3QYbCABKAsyGC5pdGVybTIuQ3JlYXRlVGFiUmVxdWVzdEgAEjYKEnNwbGl0X3BhbmVfcmVxdWVzdBhtIAEoCzIYLml0ZXJtMi5TcGxpdFBhbmVSZXF1ZXN0SAASSQocZ2V0X3Byb2ZpbGVfcHJvcGVydHlfcmVxdWVzdBhuIAEoCzIhLml0ZXJtMi5HZXRQcm9maWxlUHJvcGVydHlSZXF1ZXN0SAASOgoUc2V0X3Byb3BlcnR5X3JlcXVlc3QYbyABKAsyGi5pdGVybTIuU2V0UHJvcGVydHlSZXF1ZXN0SAASOgoUZ2V0X3Byb3BlcnR5X3JlcXVlc3QYcCABKAsyGi5pdGVybTIuR2V0UHJvcGVydHlSZXF1ZXN0SAASLwoOaW5qZWN0X3JlcXVlc3QYcSABKAsyFS5pdGVybTIuSW5qZWN0UmVxdWVzdEgAEjMKEGFjdGl2YXRlX3JlcXVlc3QYciABKAsyFy5pdGVybTIuQWN0aXZhdGVSZXF1ZXN0SAASMwoQdmFyaWFibGVfcmVxdWVzdBhzIAEoCzIXLml0ZXJtMi5WYXJpYWJsZVJlcXVlc3RIABJEChlzYXZlZF9hcnJhbmdlbWVudF9yZXF1ZXN0GHQgASgLMh8uaXRlcm0yLlNhdmVkQXJyYW5nZW1lbnRSZXF1ZXN0SAASLQoNZm9jdXNfcmVxdWVzdBh1IAEoCzIULml0ZXJtMi5Gb2N1c1JlcXVlc3RIABI8ChVsaXN0X3Byb2ZpbGVzX3JlcXVlc3QYdiABKAsyGy5pdGVybTIuTGlzdFByb2ZpbGVzUmVxdWVzdEgAElgKJHNlcnZlcl9vcmlnaW5hdGVkX3JwY19yZXN1bHRfcmVxdWVzdBh3IAEoCzIoLml0ZXJtMi5TZXJ2ZXJPcmlnaW5hdGVkUlBDUmVzdWx0UmVxdWVzdEgAEkAKF3Jlc3RhcnRfc2Vzc2lvbl9yZXF1ZXN0GHggASgLMh0uaXRlcm0yLlJlc3RhcnRTZXNzaW9uUmVxdWVzdEgAEjQKEW1lbnVfaXRlbV9yZXF1ZXN0GHkgASgLMhcuaXRlcm0yLk1lbnVJdGVtUmVxdWVzdEgAEj0KFnNldF90YWJfbGF5b3V0X3JlcXVlc3QYeiABKAsyGy5pdGVybTIuU2V0VGFiTGF5b3V0UmVxdWVzdEgAEksKHWdldF9icm9hZGNhc3RfZG9tYWluc19yZXF1ZXN0GHsgASgLMiIuaXRlcm0yLkdldEJyb2FkY2FzdERvbWFpbnNSZXF1ZXN0SAASKwoMdG11eF9yZXF1ZXN0GHwgASgLMhMuaXRlcm0yLlRtdXhSZXF1ZXN0SAASOgoUcmVvcmRlcl90YWJzX3JlcXVlc3QYfSABKAsyGi5pdGVybTIuUmVvcmRlclRhYnNSZXF1ZXN0SAASOQoTcHJlZmVyZW5jZXNfcmVxdWVzdBh+IAEoCzIaLml0ZXJtMi5QcmVmZXJlbmNlc1JlcXVlc3RIABI6ChRjb2xvcl9wcmVzZXRfcmVxdWVzdBh/IAEoCzIaLml0ZXJtMi5Db2xvclByZXNldFJlcXVlc3RIABI2ChFzZWxlY3Rpb25fcmVxdWVzdBiAASABKAsyGC5pdGVybTIuU2VsZWN0aW9uUmVxdWVzdEgAEkoKHHN0YXR1c19iYXJfY29tcG9uZW50X3JlcXVlc3QYgQEgASgLMiEuaXRlcm0yLlN0YXR1c0JhckNvbXBvbmVudFJlcXVlc3RIABJMCh1zZXRfYnJvYWRjYXN0X2RvbWFpbnNfcmVxdWVzdBiCASABKAsyIi5pdGVybTIuU2V0QnJvYWRjYXN0RG9tYWluc1JlcXVlc3RIABIuCg1jbG9zZV9yZXF1ZXN0GIMBIAEoCzIULml0ZXJtMi5DbG9zZVJlcXVlc3RIABJBChdpbnZva2VfZnVuY3Rpb25fcmVxdWVzdBiEASABKAsyHS5pdGVybTIuSW52b2tlRnVuY3Rpb25SZXF1ZXN0SAASOwoUbGlzdF9wcm9tcHRzX3JlcXVlc3QYhQEgASgLMhouaXRlcm0yLkxpc3RQcm9tcHRzUmVxdWVzdEgAQgwKCnN1Ym1lc3NhZ2Ui3REKF1NlcnZlck9yaWdpbmF0ZWRNZXNzYWdlEgoKAmlkGAEgASgDEg8KBWVycm9yGAIgASgJSAASOAoTZ2V0X2J1ZmZlcl9yZXNwb25zZRhkIAEoCzIZLml0ZXJtMi5HZXRCdWZmZXJSZXNwb25zZUgAEjgKE2dldF9wcm9tcHRfcmVzcG9uc2UYZSABKAsyGS5pdGVybTIuR2V0UHJvbXB0UmVzcG9uc2VIABI7ChR0cmFuc2FjdGlvbl9yZXNwb25zZRhmIAEoCzIbLml0ZXJtMi5UcmFuc2FjdGlvblJlc3BvbnNlSAASPQoVbm90aWZpY2F0aW9uX3Jlc3BvbnNlGGcgASgLMhwuaXRlcm0yLk5vdGlmaWNhdGlvblJlc3BvbnNlSAASPgoWcmVnaXN0ZXJfdG9vbF9yZXNwb25zZRhoIAEoCzIcLml0ZXJtMi5SZWdpc3RlclRvb2xSZXNwb25zZUgAEksKHXNldF9wcm9maWxlX3Byb3BlcnR5X3Jlc3BvbnNlGGkgASgLMiIuaXRlcm0yLlNldFByb2ZpbGVQcm9wZXJ0eVJlc3BvbnNlSAASPgoWbGlzdF9zZXNzaW9uc19yZXNwb25zZRhqIAEoCzIcLml0ZXJtMi5MaXN0U2Vzc2lvbnNSZXNwb25zZUgAEjYKEnNlbmRfdGV4dF9yZXNwb25zZRhrIAEoCzIYLml0ZXJtMi5TZW5kVGV4dFJlc3BvbnNlSAASOAoTY3JlYXRlX3RhYl9yZXNwb25zZRhsIAEoCzIZLml0ZXJtMi5DcmVhdGVUYWJSZXNwb25zZUgAEjgKE3NwbGl0X3BhbmVfcmVzcG9uc2UYbSABKAsyGS5pdGVybTIuU3BsaXRQYW5lUmVzcG9uc2VIABJLCh1nZXRfcHJvZmlsZV9wcm9wZXJ0eV9yZXNwb25zZRhuIAEoCzIiLml0ZXJtMi5HZXRQcm9maWxlUHJvcGVydHlSZXNwb25zZUgAEjwKFXNldF9wcm9wZXJ0eV9yZXNwb25zZRhvIAEoCzIbLml0ZXJtMi5TZXRQcm9wZXJ0eVJlc3BvbnNlSAASPAoVZ2V0X3Byb3BlcnR5X3Jlc3BvbnNlGHAgASgLMhsuaXRlcm0yLkdldFByb3BlcnR5UmVzcG9uc2VIABIxCg9pbmplY3RfcmVzcG9uc2UYcSABKAsyFi5pdGVybTIuSW5qZWN0UmVzcG9uc2VIABI1ChFhY3RpdmF0ZV9yZXNwb25zZRhyIAEoCzIYLml0ZXJtMi5BY3RpdmF0ZVJlc3BvbnNlSAASNQoRdmFyaWFibGVfcmVzcG9uc2UYcyABKAsyGC5pdGVybTIuVmFyaWFibGVSZXNwb25zZUgAEkYKGnNhdmVkX2FycmFuZ2VtZW50X3Jlc3BvbnNlGHQgASgLMiAuaXRlcm0yLlNhdmVkQXJyYW5nZW1lbnRSZXNwb25zZUgAEi8KDmZvY3VzX3Jlc3BvbnNlGHUgASgLMhUuaXRlcm0yLkZvY3VzUmVzcG9uc2VIABI+ChZsaXN0X3Byb2ZpbGVzX3Jlc3BvbnNlGHYgASgLMhwuaXRlcm0yLkxpc3RQcm9maWxlc1Jlc3BvbnNlSAASWgolc2VydmVyX29yaWdpbmF0ZWRfcnBjX3Jlc3VsdF9yZXNwb25zZRh3IAEoCzIpLml0ZXJtMi5TZXJ2ZXJPcmlnaW5hdGVkUlBDUmVzdWx0UmVzcG9uc2VIABJCChhyZXN0YXJ0X3Nlc3Npb25fcmVzcG9uc2UYeCABKAsyHi5pdGVybTIuUmVzdGFydFNlc3Npb25SZXNwb25zZUgAEjYKEm1lbnVfaXRlbV9yZXNwb25zZRh5IAEoCzIYLml0ZXJtMi5NZW51SXRlbVJlc3BvbnNlSAASPwoXc2V0X3RhYl9sYXlvdXRfcmVzcG9uc2UYeiABKAsyHC5pdGVybTIuU2V0VGFiTGF5b3V0UmVzcG9uc2VIABJNCh5nZXRfYnJvYWRjYXN0X2RvbWFpbnNfcmVzcG9uc2UYeyABKAsyIy5pdGVybTIuR2V0QnJvYWRjYXN0RG9tYWluc1Jlc3BvbnNlSAASLQoNdG11eF9yZXNwb25zZRh8IAEoCzIULml0ZXJtMi5UbXV4UmVzcG9uc2VIABI8ChVyZW9yZGVyX3RhYnNfcmVzcG9uc2UYfSABKAsyGy5pdGVybTIuUmVvcmRlclRhYnNSZXNwb25zZUgAEjsKFHByZWZlcmVuY2VzX3Jlc3BvbnNlGH4gASgLMhsuaXRlcm0yLlByZWZlcmVuY2VzUmVzcG9uc2VIABI8ChVjb2xvcl9wcmVzZXRfcmVzcG9uc2UYfyABKAsyGy5pdGVybTIuQ29sb3JQcmVzZXRSZXNwb25zZUgAEjgKEnNlbGVjdGlvbl9yZXNwb25zZRiAASABKAsyGS5pdGVybTIuU2VsZWN0aW9uUmVzcG9uc2VIABJMCh1zdGF0dXNfYmFyX2NvbXBvbmVudF9yZXNwb25zZRiBASABKAsyIi5pdGVybTIuU3RhdHVzQmFyQ29tcG9uZW50UmVzcG9uc2VIABJOCh5zZXRfYnJvYWRjYXN0X2RvbWFpbnNfcmVzcG9uc2UYggEgASgLMiMuaXRlcm0yLlNldEJyb2FkY2FzdERvbWFpbnNSZXNwb25zZUgAEjAKDmNsb3NlX3Jlc3BvbnNlGIMBIAEoCzIVLml0ZXJtMi5DbG9zZVJlc3BvbnNlSAASQwoYaW52b2tlX2Z1bmN0aW9uX3Jlc3BvbnNlGIQBIAEoCzIeLml0ZXJtMi5JbnZva2VGdW5jdGlvblJlc3BvbnNlSAASPQoVbGlzdF9wcm9tcHRzX3Jlc3BvbnNlGIUBIAEoCzIbLml0ZXJtMi5MaXN0UHJvbXB0c1Jlc3BvbnNlSAASLQoMbm90aWZpY2F0aW9uGOgHIAEoCzIULml0ZXJtMi5Ob3RpZmljYXRpb25IAEIMCgpzdWJtZXNzYWdlIs8DChVJbnZva2VGdW5jdGlvblJlcXVlc3QSMAoDdGFiGAEgASgLMiEuaXRlcm0yLkludm9rZUZ1bmN0aW9uUmVxdWVzdC5UYWJIABI4CgdzZXNzaW9uGAIgASgLMiUuaXRlcm0yLkludm9rZUZ1bmN0aW9uUmVxdWVzdC5TZXNzaW9uSAASNgoGd2luZG93GAMgASgLMiQuaXRlcm0yLkludm9rZUZ1bmN0aW9uUmVxdWVzdC5XaW5kb3dIABIwCgNhcHAYBCABKAsyIS5pdGVybTIuSW52b2tlRnVuY3Rpb25SZXF1ZXN0LkFwcEgAEjYKBm1ldGhvZBgHIAEoCzIkLml0ZXJtMi5JbnZva2VGdW5jdGlvblJlcXVlc3QuTWV0aG9kSAASEgoKaW52b2NhdGlvbhgFIAEoCRITCgd0aW1lb3V0GAYgASgBOgItMRoVCgNUYWISDgoGdGFiX2lkGAEgASgJGh0KB1Nlc3Npb24SEgoKc2Vzc2lvbl9pZBgBIAEoCRobCgZXaW5kb3cSEQoJd2luZG93X2lkGAEgASgJGgUKA0FwcBoaCgZNZXRob2QSEAoIcmVjZWl2ZXIYASABKAlCCQoHY29udGV4dCLZAgoWSW52b2tlRnVuY3Rpb25SZXNwb25zZRI1CgVlcnJvchgBIAEoCzIkLml0ZXJtMi5JbnZva2VGdW5jdGlvblJlc3BvbnNlLkVycm9ySAASOQoHc3VjY2VzcxgCIAEoCzImLml0ZXJtMi5JbnZva2VGdW5jdGlvblJlc3BvbnNlLlN1Y2Nlc3NIABpUCgVFcnJvchI1CgZzdGF0dXMYASABKA4yJS5pdGVybTIuSW52b2tlRnVuY3Rpb25SZXNwb25zZS5TdGF0dXMSFAoMZXJyb3JfcmVhc29uGAIgASgJGh4KB1N1Y2Nlc3MSEwoLanNvbl9yZXN1bHQYASABKAkiSAoGU3RhdHVzEgsKB1RJTUVPVVQQARIKCgZGQUlMRUQQAhIVChFSRVFVRVNUX01BTEZPUk1FRBADEg4KCklOVkFMSURfSUQQBEINCgtkaXNwb3NpdGlvbiKtAgoMQ2xvc2VSZXF1ZXN0Ei4KBHRhYnMYASABKAsyHi5pdGVybTIuQ2xvc2VSZXF1ZXN0LkNsb3NlVGFic0gAEjYKCHNlc3Npb25zGAIgASgLMiIuaXRlcm0yLkNsb3NlUmVxdWVzdC5DbG9zZVNlc3Npb25zSAASNAoHd2luZG93cxgDIAEoCzIhLml0ZXJtMi5DbG9zZVJlcXVlc3QuQ2xvc2VXaW5kb3dzSAASDQoFZm9yY2UYBCABKAgaHAoJQ2xvc2VUYWJzEg8KB3RhYl9pZHMYASADKAkaJAoNQ2xvc2VTZXNzaW9ucxITCgtzZXNzaW9uX2lkcxgBIAMoCRoiCgxDbG9zZVdpbmRvd3MSEgoKd2luZG93X2lkcxgBIAMoCUIICgZ0YXJnZXQicwoNQ2xvc2VSZXNwb25zZRIuCghzdGF0dXNlcxgBIAMoDjIcLml0ZXJtMi5DbG9zZVJlc3BvbnNlLlN0YXR1cyIyCgZTdGF0dXMSBgoCT0sQABINCglOT1RfRk9VTkQQARIRCg1VU0VSX0RFQ0xJTkVEEAIiUAoaU2V0QnJvYWRjYXN0RG9tYWluc1JlcXVlc3QSMgoRYnJvYWRjYXN0X2RvbWFpbnMYASADKAsyFy5pdGVybTIuQnJvYWRjYXN0RG9tYWluIscBChtTZXRCcm9hZGNhc3REb21haW5zUmVzcG9uc2USOgoGc3RhdHVzGAEgASgOMiouaXRlcm0yLlNldEJyb2FkY2FzdERvbWFpbnNSZXNwb25zZS5TdGF0dXMibAoGU3RhdHVzEgYKAk9LEAASFQoRU0VTU0lPTl9OT1RfRk9VTkQQARIiCh5CUk9BRENBU1RfRE9NQUlOU19OT1RfRElTSk9JTlQQAhIfChtTRVNTSU9OU19OT1RfSU5fU0FNRV9XSU5ET1cQAyLOAQoZU3RhdHVzQmFyQ29tcG9uZW50UmVxdWVzdBJFCgxvcGVuX3BvcG92ZXIYASABKAsyLS5pdGVybTIuU3RhdHVzQmFyQ29tcG9uZW50UmVxdWVzdC5PcGVuUG9wb3ZlckgAEhIKCmlkZW50aWZpZXIYAiABKAkaSwoLT3BlblBvcG92ZXISEgoKc2Vzc2lvbl9pZBgBIAEoCRIMCgRodG1sGAIgASgJEhoKBHNpemUYAyABKAsyDC5pdGVybTIuU2l6ZUIJCgdyZXF1ZXN0Iq8BChpTdGF0dXNCYXJDb21wb25lbnRSZXNwb25zZRI5CgZzdGF0dXMYASABKA4yKS5pdGVybTIuU3RhdHVzQmFyQ29tcG9uZW50UmVzcG9uc2UuU3RhdHVzIlYKBlN0YXR1cxIGCgJPSxAAEhUKEVNFU1NJT05fTk9UX0ZPVU5EEAESFQoRUkVRVUVTVF9NQUxGT1JNRUQQAhIWChJJTlZBTElEX0lERU5USUZJRVIQAyJdChJXaW5kb3dlZENvb3JkUmFuZ2USJwoLY29vcmRfcmFuZ2UYASABKAsyEi5pdGVybTIuQ29vcmRSYW5nZRIeCgdjb2x1bW5zGAIgASgLMg0uaXRlcm0yLlJhbmdlIooBCgxTdWJTZWxlY3Rpb24SOAoUd2luZG93ZWRfY29vcmRfcmFuZ2UYASABKAsyGi5pdGVybTIuV2luZG93ZWRDb29yZFJhbmdlEi0KDnNlbGVjdGlvbl9tb2RlGAIgASgOMhUuaXRlcm0yLlNlbGVjdGlvbk1vZGUSEQoJY29ubmVjdGVkGAMgASgIIjkKCVNlbGVjdGlvbhIsCg5zdWJfc2VsZWN0aW9ucxgBIAMoCzIULml0ZXJtMi5TdWJTZWxlY3Rpb24itwIKEFNlbGVjdGlvblJlcXVlc3QSTQoVZ2V0X3NlbGVjdGlvbl9yZXF1ZXN0GAEgASgLMiwuaXRlcm0yLlNlbGVjdGlvblJlcXVlc3QuR2V0U2VsZWN0aW9uUmVxdWVzdEgAEk0KFXNldF9zZWxlY3Rpb25fcmVxdWVzdBgCIAEoCzIsLml0ZXJtMi5TZWxlY3Rpb25SZXF1ZXN0LlNldFNlbGVjdGlvblJlcXVlc3RIABopChNHZXRTZWxlY3Rpb25SZXF1ZXN0EhIKCnNlc3Npb25faWQYASABKAkaTwoTU2V0U2VsZWN0aW9uUmVxdWVzdBISCgpzZXNzaW9uX2lkGAEgASgJEiQKCXNlbGVjdGlvbhgCIAEoCzIRLml0ZXJtMi5TZWxlY3Rpb25CCQoHcmVxdWVzdCKcAwoRU2VsZWN0aW9uUmVzcG9uc2USMAoGc3RhdHVzGAEgASgOMiAuaXRlcm0yLlNlbGVjdGlvblJlc3BvbnNlLlN0YXR1cxJQChZnZXRfc2VsZWN0aW9uX3Jlc3BvbnNlGAIgASgLMi4uaXRlcm0yLlNlbGVjdGlvblJlc3BvbnNlLkdldFNlbGVjdGlvblJlc3BvbnNlSAASUAoWc2V0X3NlbGVjdGlvbl9yZXNwb25zZRgDIAEoCzIuLml0ZXJtMi5TZWxlY3Rpb25SZXNwb25zZS5TZXRTZWxlY3Rpb25SZXNwb25zZUgAGjwKFEdldFNlbGVjdGlvblJlc3BvbnNlEiQKCXNlbGVjdGlvbhgCIAEoCzIRLml0ZXJtMi5TZWxlY3Rpb24aFgoUU2V0U2VsZWN0aW9uUmVzcG9uc2UiTwoGU3RhdHVzEgYKAk9LEAASEwoPSU5WQUxJRF9TRVNTSU9OEAESEQoNSU5WQUxJRF9SQU5HRRACEhUKEVJFUVVFU1RfTUFMRk9STUVEEANCCgoIcmVzcG9uc2UixQEKEkNvbG9yUHJlc2V0UmVxdWVzdBI+CgxsaXN0X3ByZXNldHMYASABKAsyJi5pdGVybTIuQ29sb3JQcmVzZXRSZXF1ZXN0Lkxpc3RQcmVzZXRzSAASOgoKZ2V0X3ByZXNldBgCIAEoCzIkLml0ZXJtMi5Db2xvclByZXNldFJlcXVlc3QuR2V0UHJlc2V0SAAaDQoLTGlzdFByZXNldHMaGQoJR2V0UHJlc2V0EgwKBG5hbWUYASABKAlCCQoHcmVxdWVzdCL0AwoTQ29sb3JQcmVzZXRSZXNwb25zZRI/CgxsaXN0X3ByZXNldHMYASABKAsyJy5pdGVybTIuQ29sb3JQcmVzZXRSZXNwb25zZS5MaXN0UHJlc2V0c0gAEjsKCmdldF9wcmVzZXQYAiABKAsyJS5pdGVybTIuQ29sb3JQcmVzZXRSZXNwb25zZS5HZXRQcmVzZXRIABIyCgZzdGF0dXMYAyABKA4yIi5pdGVybTIuQ29sb3JQcmVzZXRSZXNwb25zZS5TdGF0dXMaGwoLTGlzdFByZXNldHMSDAoEbmFtZRgBIAMoCRrCAQoJR2V0UHJlc2V0EkoKDmNvbG9yX3NldHRpbmdzGAEgAygLMjIuaXRlcm0yLkNvbG9yUHJlc2V0UmVzcG9uc2UuR2V0UHJlc2V0LkNvbG9yU2V0dGluZxppCgxDb2xvclNldHRpbmcSCwoDcmVkGAEgASgCEg0KBWdyZWVuGAIgASgCEgwKBGJsdWUYAyABKAISDQoFYWxwaGEYBCABKAISEwoLY29sb3Jfc3BhY2UYBSABKAkSCwoDa2V5GAYgASgJIj0KBlN0YXR1cxIGCgJPSxAAEhQKEFBSRVNFVF9OT1RfRk9VTkQQARIVChFSRVFVRVNUX01BTEZPUk1FRBACQgoKCHJlc3BvbnNlIssEChJQcmVmZXJlbmNlc1JlcXVlc3QSNAoIcmVxdWVzdHMYASADKAsyIi5pdGVybTIuUHJlZmVyZW5jZXNSZXF1ZXN0LlJlcXVlc3Qa/gMKB1JlcXVlc3QSUgoWc2V0X3ByZWZlcmVuY2VfcmVxdWVzdBgBIAEoCzIwLml0ZXJtMi5QcmVmZXJlbmNlc1JlcXVlc3QuUmVxdWVzdC5TZXRQcmVmZXJlbmNlSAASUgoWZ2V0X3ByZWZlcmVuY2VfcmVxdWVzdBgCIAEoCzIwLml0ZXJtMi5QcmVmZXJlbmNlc1JlcXVlc3QuUmVxdWVzdC5HZXRQcmVmZXJlbmNlSAASWwobc2V0X2RlZmF1bHRfcHJvZmlsZV9yZXF1ZXN0GAMgASgLMjQuaXRlcm0yLlByZWZlcmVuY2VzUmVxdWVzdC5SZXF1ZXN0LlNldERlZmF1bHRQcm9maWxlSAASWwobZ2V0X2RlZmF1bHRfcHJvZmlsZV9yZXF1ZXN0GAQgASgLMjQuaXRlcm0yLlByZWZlcmVuY2VzUmVxdWVzdC5SZXF1ZXN0LkdldERlZmF1bHRQcm9maWxlSAAaMAoNU2V0UHJlZmVyZW5jZRILCgNrZXkYASABKAkSEgoKanNvbl92YWx1ZRgCIAEoCRocCg1HZXRQcmVmZXJlbmNlEgsKA2tleRgBIAEoCRohChFTZXREZWZhdWx0UHJvZmlsZRIMCgRndWlkGAEgASgJGhMKEUdldERlZmF1bHRQcm9maWxlQgkKB3JlcXVlc3QivwcKE1ByZWZlcmVuY2VzUmVzcG9uc2USMwoHcmVzdWx0cxgBIAMoCzIiLml0ZXJtMi5QcmVmZXJlbmNlc1Jlc3BvbnNlLlJlc3VsdBryBgoGUmVzdWx0ElUKFHVucmVjb2duaXplZF9yZXF1ZXN0GAEgASgLMjUuaXRlcm0yLlByZWZlcmVuY2VzUmVzcG9uc2UuUmVzdWx0LlVucmVjb2duaXplZFJlc3VsdEgAElcKFXNldF9wcmVmZXJlbmNlX3Jlc3VsdBgCIAEoCzI2Lml0ZXJtMi5QcmVmZXJlbmNlc1Jlc3BvbnNlLlJlc3VsdC5TZXRQcmVmZXJlbmNlUmVzdWx0SAASVwoVZ2V0X3ByZWZlcmVuY2VfcmVzdWx0GAMgASgLMjYuaXRlcm0yLlByZWZlcmVuY2VzUmVzcG9uc2UuUmVzdWx0LkdldFByZWZlcmVuY2VSZXN1bHRIABJgChpzZXRfZGVmYXVsdF9wcm9maWxlX3Jlc3VsdBgEIAEoCzI6Lml0ZXJtMi5QcmVmZXJlbmNlc1Jlc3BvbnNlLlJlc3VsdC5TZXREZWZhdWx0UHJvZmlsZVJlc3VsdEgAEmAKGmdldF9kZWZhdWx0X3Byb2ZpbGVfcmVzdWx0GAUgASgLMjouaXRlcm0yLlByZWZlcmVuY2VzUmVzcG9uc2UuUmVzdWx0LkdldERlZmF1bHRQcm9maWxlUmVzdWx0SAAalwEKE1NldFByZWZlcmVuY2VSZXN1bHQSTQoGc3RhdHVzGAEgASgOMj0uaXRlcm0yLlByZWZlcmVuY2VzUmVzcG9uc2UuUmVzdWx0LlNldFByZWZlcmVuY2VSZXN1bHQuU3RhdHVzIjEKBlN0YXR1cxIGCgJPSxAAEgwKCEJBRF9KU09OEAESEQoNSU5WQUxJRF9WQUxVRRACGikKE0dldFByZWZlcmVuY2VSZXN1bHQSEgoKanNvbl92YWx1ZRgBIAEoCRqMAQoXU2V0RGVmYXVsdFByb2ZpbGVSZXN1bHQSUQoGc3RhdHVzGAEgASgOMkEuaXRlcm0yLlByZWZlcmVuY2VzUmVzcG9uc2UuUmVzdWx0LlNldERlZmF1bHRQcm9maWxlUmVzdWx0LlN0YXR1cyIeCgZTdGF0dXMSBgoCT0sQABIMCghCQURfR1VJRBABGhQKElVucmVjb2duaXplZFJlc3VsdBonChdHZXREZWZhdWx0UHJvZmlsZVJlc3VsdBIMCgRndWlkGAEgASgJQggKBnJlc3VsdCKCAQoSUmVvcmRlclRhYnNSZXF1ZXN0EjoKC2Fzc2lnbm1lbnRzGAMgAygLMiUuaXRlcm0yLlJlb3JkZXJUYWJzUmVxdWVzdC5Bc3NpZ25tZW50GjAKCkFzc2lnbm1lbnQSEQoJd2luZG93X2lkGAEgASgJEg8KB3RhYl9pZHMYAiADKAkingEKE1Jlb3JkZXJUYWJzUmVzcG9uc2USMgoGc3RhdHVzGAQgASgOMiIuaXRlcm0yLlJlb3JkZXJUYWJzUmVzcG9uc2UuU3RhdHVzIlMKBlN0YXR1cxIGCgJPSxAAEhYKEklOVkFMSURfQVNTSUdOTUVOVBABEhUKEUlOVkFMSURfV0lORE9XX0lEEAISEgoOSU5WQUxJRF9UQUJfSUQQAyLjAwoLVG11eFJlcXVlc3QSPwoQbGlzdF9jb25uZWN0aW9ucxgBIAEoCzIjLml0ZXJtMi5UbXV4UmVxdWVzdC5MaXN0Q29ubmVjdGlvbnNIABI3CgxzZW5kX2NvbW1hbmQYAiABKAsyHy5pdGVybTIuVG11eFJlcXVlc3QuU2VuZENvbW1hbmRIABJCChJzZXRfd2luZG93X3Zpc2libGUYAyABKAsyJC5pdGVybTIuVG11eFJlcXVlc3QuU2V0V2luZG93VmlzaWJsZUgAEjkKDWNyZWF0ZV93aW5kb3cYBCABKAsyIC5pdGVybTIuVG11eFJlcXVlc3QuQ3JlYXRlV2luZG93SAAaEQoPTGlzdENvbm5lY3Rpb25zGjUKC1NlbmRDb21tYW5kEhUKDWNvbm5lY3Rpb25faWQYASABKAkSDwoHY29tbWFuZBgCIAEoCRpNChBTZXRXaW5kb3dWaXNpYmxlEhUKDWNvbm5lY3Rpb25faWQYASABKAkSEQoJd2luZG93X2lkGAIgASgJEg8KB3Zpc2libGUYAyABKAgaNwoMQ3JlYXRlV2luZG93EhUKDWNvbm5lY3Rpb25faWQYASABKAkSEAoIYWZmaW5pdHkYAiABKAlCCQoHcGF5bG9hZCKJBQoMVG11eFJlc3BvbnNlEkAKEGxpc3RfY29ubmVjdGlvbnMYASABKAsyJC5pdGVybTIuVG11eFJlc3BvbnNlLkxpc3RDb25uZWN0aW9uc0gAEjgKDHNlbmRfY29tbWFuZBgCIAEoCzIgLml0ZXJtMi5UbXV4UmVzcG9uc2UuU2VuZENvbW1hbmRIABJDChJzZXRfd2luZG93X3Zpc2libGUYAyABKAsyJS5pdGVybTIuVG11eFJlc3BvbnNlLlNldFdpbmRvd1Zpc2libGVIABI6Cg1jcmVhdGVfd2luZG93GAUgASgLMiEuaXRlcm0yLlRtdXhSZXNwb25zZS5DcmVhdGVXaW5kb3dIABIrCgZzdGF0dXMYBCABKA4yGy5pdGVybTIuVG11eFJlc3BvbnNlLlN0YXR1cxqXAQoPTGlzdENvbm5lY3Rpb25zEkQKC2Nvbm5lY3Rpb25zGAEgAygLMi8uaXRlcm0yLlRtdXhSZXNwb25zZS5MaXN0Q29ubmVjdGlvbnMuQ29ubmVjdGlvbho+CgpDb25uZWN0aW9uEhUKDWNvbm5lY3Rpb25faWQYASABKAkSGQoRb3duaW5nX3Nlc3Npb25faWQYAiABKAkaHQoLU2VuZENvbW1hbmQSDgoGb3V0cHV0GAEgASgJGhIKEFNldFdpbmRvd1Zpc2libGUaHgoMQ3JlYXRlV2luZG93Eg4KBnRhYl9pZBgBIAEoCSJXCgZTdGF0dXMSBgoCT0sQABITCg9JTlZBTElEX1JFUVVFU1QQARIZChVJTlZBTElEX0NPTk5FQ1RJT05fSUQQAhIVChFJTlZBTElEX1dJTkRPV19JRBADQgkKB3BheWxvYWQiHAoaR2V0QnJvYWRjYXN0RG9tYWluc1JlcXVlc3QiJgoPQnJvYWRjYXN0RG9tYWluEhMKC3Nlc3Npb25faWRzGAEgAygJIlEKG0dldEJyb2FkY2FzdERvbWFpbnNSZXNwb25zZRIyChFicm9hZGNhc3RfZG9tYWlucxgBIAMoCzIXLml0ZXJtMi5Ccm9hZGNhc3REb21haW4iSgoTU2V0VGFiTGF5b3V0UmVxdWVzdBIjCgRyb290GAEgASgLMhUuaXRlcm0yLlNwbGl0VHJlZU5vZGUSDgoGdGFiX2lkGAIgASgJIo8BChRTZXRUYWJMYXlvdXRSZXNwb25zZRIzCgZzdGF0dXMYASABKA4yIy5pdGVybTIuU2V0VGFiTGF5b3V0UmVzcG9uc2UuU3RhdHVzIkIKBlN0YXR1cxIGCgJPSxAAEg4KCkJBRF9UQUJfSUQQARIOCgpXUk9OR19UUkVFEAISEAoMSU5WQUxJRF9TSVpFEAMiOQoPTWVudUl0ZW1SZXF1ZXN0EhIKCmlkZW50aWZpZXIYASABKAkSEgoKcXVlcnlfb25seRgCIAEoCCKZAQoQTWVudUl0ZW1SZXNwb25zZRIvCgZzdGF0dXMYASABKA4yHy5pdGVybTIuTWVudUl0ZW1SZXNwb25zZS5TdGF0dXMSDwoHY2hlY2tlZBgCIAEoCBIPCgdlbmFibGVkGAMgASgIIjIKBlN0YXR1cxIGCgJPSxAAEhIKDkJBRF9JREVOVElGSUVSEAESDAoIRElTQUJMRUQQAiJDChVSZXN0YXJ0U2Vzc2lvblJlcXVlc3QSEgoKc2Vzc2lvbl9pZBgBIAEoCRIWCg5vbmx5X2lmX2V4aXRlZBgCIAEoCCKVAQoWUmVzdGFydFNlc3Npb25SZXNwb25zZRI1CgZzdGF0dXMYASABKA4yJS5pdGVybTIuUmVzdGFydFNlc3Npb25SZXNwb25zZS5TdGF0dXMiRAoGU3RhdHVzEgYKAk9LEAASFQoRU0VTU0lPTl9OT1RfRk9VTkQQARIbChdTRVNTSU9OX05PVF9SRVNUQVJUQUJMRRACInAKIFNlcnZlck9yaWdpbmF0ZWRSUENSZXN1bHRSZXF1ZXN0EhIKCnJlcXVlc3RfaWQYASABKAkSGAoOanNvbl9leGNlcHRpb24YAiABKAlIABIUCgpqc29uX3ZhbHVlGAMgASgJSABCCAoGcmVzdWx0IiMKIVNlcnZlck9yaWdpbmF0ZWRSUENSZXN1bHRSZXNwb25zZSI4ChNMaXN0UHJvZmlsZXNSZXF1ZXN0EhIKCnByb3BlcnRpZXMYASADKAkSDQoFZ3VpZHMYAiADKAkihgEKFExpc3RQcm9maWxlc1Jlc3BvbnNlEjYKCHByb2ZpbGVzGAEgAygLMiQuaXRlcm0yLkxpc3RQcm9maWxlc1Jlc3BvbnNlLlByb2ZpbGUaNgoHUHJvZmlsZRIrCgpwcm9wZXJ0aWVzGAEgAygLMhcuaXRlcm0yLlByb2ZpbGVQcm9wZXJ0eSIOCgxGb2N1c1JlcXVlc3QiSAoNRm9jdXNSZXNwb25zZRI3Cg1ub3RpZmljYXRpb25zGAEgAygLMiAuaXRlcm0yLkZvY3VzQ2hhbmdlZE5vdGlmaWNhdGlvbiKdAQoXU2F2ZWRBcnJhbmdlbWVudFJlcXVlc3QSDAoEbmFtZRgBIAEoCRI2CgZhY3Rpb24YAiABKA4yJi5pdGVybTIuU2F2ZWRBcnJhbmdlbWVudFJlcXVlc3QuQWN0aW9uEhEKCXdpbmRvd19pZBgDIAEoCSIpCgZBY3Rpb24SCwoHUkVTVE9SRRAAEggKBFNBVkUQARIICgRMSVNUEAIivAEKGFNhdmVkQXJyYW5nZW1lbnRSZXNwb25zZRI3CgZzdGF0dXMYASABKA4yJy5pdGVybTIuU2F2ZWRBcnJhbmdlbWVudFJlc3BvbnNlLlN0YXR1cxINCgVuYW1lcxgCIAMoCSJYCgZTdGF0dXMSBgoCT0sQABIZChVBUlJBTkdFTUVOVF9OT1RfRk9VTkQQARIUChBXSU5ET1dfTk9UX0ZPVU5EEAISFQoRUkVRVUVTVF9NQUxGT1JNRUQQAyLBAQoPVmFyaWFibGVSZXF1ZXN0EhQKCnNlc3Npb25faWQYASABKAlIABIQCgZ0YWJfaWQYBCABKAlIABINCgNhcHAYBSABKAhIABITCgl3aW5kb3dfaWQYBiABKAlIABIoCgNzZXQYAiADKAsyGy5pdGVybTIuVmFyaWFibGVSZXF1ZXN0LlNldBILCgNnZXQYAyADKAkaIgoDU2V0EgwKBG5hbWUYASABKAkSDQoFdmFsdWUYAiABKAlCBwoFc2NvcGUi5QEKEFZhcmlhYmxlUmVzcG9uc2USLwoGc3RhdHVzGAEgASgOMh8uaXRlcm0yLlZhcmlhYmxlUmVzcG9uc2UuU3RhdHVzEg4KBnZhbHVlcxgCIAMoCSKPAQoGU3RhdHVzEgYKAk9LEAASFQoRU0VTU0lPTl9OT1RfRk9VTkQQARIQCgxJTlZBTElEX05BTUUQAhIRCg1NSVNTSU5HX1NDT1BFEAMSEQoNVEFCX05PVF9GT1VORBAEEhgKFE1VTFRJX0dFVF9ESVNBTExPV0VEEAUSFAoQV0lORE9XX05PVF9GT1VORBAGIpYCCg9BY3RpdmF0ZVJlcXVlc3QSEwoJd2luZG93X2lkGAEgASgJSAASEAoGdGFiX2lkGAIgASgJSAASFAoKc2Vzc2lvbl9pZBgDIAEoCUgAEhoKEm9yZGVyX3dpbmRvd19mcm9udBgEIAEoCBISCgpzZWxlY3RfdGFiGAUgASgIEhYKDnNlbGVjdF9zZXNzaW9uGAYgASgIEjEKDGFjdGl2YXRlX2FwcBgHIAEoCzIbLml0ZXJtMi5BY3RpdmF0ZVJlcXVlc3QuQXBwGj0KA0FwcBIZChFyYWlzZV9hbGxfd2luZG93cxgBIAEoCBIbChNpZ25vcmluZ19vdGhlcl9hcHBzGAIgASgIQgwKCmlkZW50aWZpZXIifQoQQWN0aXZhdGVSZXNwb25zZRIvCgZzdGF0dXMYASABKA4yHy5pdGVybTIuQWN0aXZhdGVSZXNwb25zZS5TdGF0dXMiOAoGU3RhdHVzEgYKAk9LEAASEgoOQkFEX0lERU5USUZJRVIQARISCg5JTlZBTElEX09QVElPThACIjEKDUluamVjdFJlcXVlc3QSEgoKc2Vzc2lvbl9pZBgBIAMoCRIMCgRkYXRhGAIgASgMImgKDkluamVjdFJlc3BvbnNlEi0KBnN0YXR1cxgBIAMoDjIdLml0ZXJtMi5JbmplY3RSZXNwb25zZS5TdGF0dXMiJwoGU3RhdHVzEgYKAk9LEAASFQoRU0VTU0lPTl9OT1RfRk9VTkQQASJbChJHZXRQcm9wZXJ0eVJlcXVlc3QSEwoJd2luZG93X2lkGAEgASgJSAASFAoKc2Vzc2lvbl9pZBgDIAEoCUgAEgwKBG5hbWUYAiABKAlCDAoKaWRlbnRpZmllciKaAQoTR2V0UHJvcGVydHlSZXNwb25zZRIyCgZzdGF0dXMYASABKA4yIi5pdGVybTIuR2V0UHJvcGVydHlSZXNwb25zZS5TdGF0dXMSEgoKanNvbl92YWx1ZRgCIAEoCSI7CgZTdGF0dXMSBgoCT0sQABIVChFVTlJFQ09HTklaRURfTkFNRRABEhIKDklOVkFMSURfVEFSR0VUEAIibwoSU2V0UHJvcGVydHlSZXF1ZXN0EhMKCXdpbmRvd19pZBgBIAEoCUgAEhQKCnNlc3Npb25faWQYBSABKAlIABIMCgRuYW1lGAMgASgJEhIKCmpzb25fdmFsdWUYBCABKAlCDAoKaWRlbnRpZmllciLDAQoTU2V0UHJvcGVydHlSZXNwb25zZRIyCgZzdGF0dXMYASABKA4yIi5pdGVybTIuU2V0UHJvcGVydHlSZXNwb25zZS5TdGF0dXMieAoGU3RhdHVzEgYKAk9LEAASFQoRVU5SRUNPR05JWkVEX05BTUUQARIRCg1JTlZBTElEX1ZBTFVFEAISEgoOSU5WQUxJRF9UQVJHRVQQAxIMCghERUZFUlJFRBAEEg4KCklNUE9TU0lCTEUQBRIKCgZGQUlMRUQQBiLYAQoTUmVnaXN0ZXJUb29sUmVxdWVzdBIMCgRuYW1lGAEgASgJEhIKCmlkZW50aWZpZXIYAiABKAkSKwoccmV2ZWFsX2lmX2FscmVhZHlfcmVnaXN0ZXJlZBgFIAEoCDoFZmFsc2USRgoJdG9vbF90eXBlGAMgASgOMiQuaXRlcm0yLlJlZ2lzdGVyVG9vbFJlcXVlc3QuVG9vbFR5cGU6DVdFQl9WSUVXX1RPT0wSCwoDVVJMGAQgASgJIh0KCFRvb2xUeXBlEhEKDVdFQl9WSUVXX1RPT0wQASLfDAoWUlBDUmVnaXN0cmF0aW9uUmVxdWVzdBIMCgRuYW1lGAEgASgJEkYKCWFyZ3VtZW50cxgCIAMoCzIzLml0ZXJtMi5SUENSZWdpc3RyYXRpb25SZXF1ZXN0LlJQQ0FyZ3VtZW50U2lnbmF0dXJlEjwKCGRlZmF1bHRzGAQgAygLMiouaXRlcm0yLlJQQ1JlZ2lzdHJhdGlvblJlcXVlc3QuUlBDQXJndW1lbnQSDwoHdGltZW91dBgDIAEoAhI6CgRyb2xlGAUgASgOMiMuaXRlcm0yLlJQQ1JlZ2lzdHJhdGlvblJlcXVlc3QuUm9sZToHR0VORVJJQxJZChhzZXNzaW9uX3RpdGxlX2F0dHJpYnV0ZXMYByABKAsyNS5pdGVybTIuUlBDUmVnaXN0cmF0aW9uUmVxdWVzdC5TZXNzaW9uVGl0bGVBdHRyaWJ1dGVzSAASZgofc3RhdHVzX2Jhcl9jb21wb25lbnRfYXR0cmlidXRlcxgIIAEoCzI7Lml0ZXJtMi5SUENSZWdpc3RyYXRpb25SZXF1ZXN0LlN0YXR1c0JhckNvbXBvbmVudEF0dHJpYnV0ZXNIABJXChdjb250ZXh0X21lbnVfYXR0cmlidXRlcxgJIAEoCzI0Lml0ZXJtMi5SUENSZWdpc3RyYXRpb25SZXF1ZXN0LkNvbnRleHRNZW51QXR0cmlidXRlc0gAEhgKDGRpc3BsYXlfbmFtZRgGIAEoCUICGAEaJAoUUlBDQXJndW1lbnRTaWduYXR1cmUSDAoEbmFtZRgBIAEoCRopCgtSUENBcmd1bWVudBIMCgRuYW1lGAEgASgJEgwKBHBhdGgYAiABKAkaSQoWU2Vzc2lvblRpdGxlQXR0cmlidXRlcxIUCgxkaXNwbGF5X25hbWUYASABKAkSGQoRdW5pcXVlX2lkZW50aWZpZXIYBiABKAka2QUKHFN0YXR1c0JhckNvbXBvbmVudEF0dHJpYnV0ZXMSGQoRc2hvcnRfZGVzY3JpcHRpb24YASABKAkSHAoUZGV0YWlsZWRfZGVzY3JpcHRpb24YAiABKAkSTwoFa25vYnMYAyADKAsyQC5pdGVybTIuUlBDUmVnaXN0cmF0aW9uUmVxdWVzdC5TdGF0dXNCYXJDb21wb25lbnRBdHRyaWJ1dGVzLktub2ISEAoIZXhlbXBsYXIYBCABKAkSFgoOdXBkYXRlX2NhZGVuY2UYBSABKAISGQoRdW5pcXVlX2lkZW50aWZpZXIYBiABKAkSTwoFaWNvbnMYByADKAsyQC5pdGVybTIuUlBDUmVnaXN0cmF0aW9uUmVxdWVzdC5TdGF0dXNCYXJDb21wb25lbnRBdHRyaWJ1dGVzLkljb24SXgoGZm9ybWF0GAggASgOMkIuaXRlcm0yLlJQQ1JlZ2lzdHJhdGlvblJlcXVlc3QuU3RhdHVzQmFyQ29tcG9uZW50QXR0cmlidXRlcy5Gb3JtYXQ6ClBMQUlOX1RFWFQa7wEKBEtub2ISDAoEbmFtZRgBIAEoCRJTCgR0eXBlGAIgASgOMkUuaXRlcm0yLlJQQ1JlZ2lzdHJhdGlvblJlcXVlc3QuU3RhdHVzQmFyQ29tcG9uZW50QXR0cmlidXRlcy5Lbm9iLlR5cGUSEwoLcGxhY2Vob2xkZXIYAyABKAkSGgoSanNvbl9kZWZhdWx0X3ZhbHVlGAQgASgJEgsKA2tleRgFIAEoCSJGCgRUeXBlEgwKCENoZWNrYm94EAESCgoGU3RyaW5nEAISGQoVUG9zaXRpdmVGbG9hdGluZ1BvaW50EAMSCQoFQ29sb3IQBBojCgRJY29uEgwKBGRhdGEYASABKAwSDQoFc2NhbGUYAiABKAIiIgoGRm9ybWF0Eg4KClBMQUlOX1RFWFQQABIICgRIVE1MEAEaSAoVQ29udGV4dE1lbnVBdHRyaWJ1dGVzEhQKDGRpc3BsYXlfbmFtZRgBIAEoCRIZChF1bmlxdWVfaWRlbnRpZmllchgCIAEoCSJSCgRSb2xlEgsKB0dFTkVSSUMQARIRCg1TRVNTSU9OX1RJVExFEAISGAoUU1RBVFVTX0JBUl9DT01QT05FTlQQAxIQCgxDT05URVhUX01FTlUQBEIYChZSb2xlU3BlY2lmaWNBdHRyaWJ1dGVzIosBChRSZWdpc3RlclRvb2xSZXNwb25zZRIzCgZzdGF0dXMYASABKA4yIy5pdGVybTIuUmVnaXN0ZXJUb29sUmVzcG9uc2UuU3RhdHVzIj4KBlN0YXR1cxIGCgJPSxAAEhUKEVJFUVVFU1RfTUFMRk9STUVEEAESFQoRUEVSTUlTU0lPTl9ERU5JRUQQAiK+AQoQS2V5c3Ryb2tlUGF0dGVybhItChJyZXF1aXJlZF9tb2RpZmllcnMYASADKA4yES5pdGVybTIuTW9kaWZpZXJzEi4KE2ZvcmJpZGRlbl9tb2RpZmllcnMYAiADKA4yES5pdGVybTIuTW9kaWZpZXJzEhAKCGtleWNvZGVzGAMgAygFEhIKCmNoYXJhY3RlcnMYBCADKAkSJQodY2hhcmFjdGVyc19pZ25vcmluZ19tb2RpZmllcnMYBSADKAkiZQoXS2V5c3Ryb2tlTW9uaXRvclJlcXVlc3QSOAoScGF0dGVybnNfdG9faWdub3JlGAEgAygLMhguaXRlcm0yLktleXN0cm9rZVBhdHRlcm5CAhgBEhAKCGFkdmFuY2VkGAIgASgIIk4KFktleXN0cm9rZUZpbHRlclJlcXVlc3QSNAoScGF0dGVybnNfdG9faWdub3JlGAEgAygLMhguaXRlcm0yLktleXN0cm9rZVBhdHRlcm4iYAoWVmFyaWFibGVNb25pdG9yUmVxdWVzdBIMCgRuYW1lGAEgASgJEiQKBXNjb3BlGAIgASgOMhUuaXRlcm0yLlZhcmlhYmxlU2NvcGUSEgoKaWRlbnRpZmllchgDIAEoCSIkChRQcm9maWxlQ2hhbmdlUmVxdWVzdBIMCgRndWlkGAEgASgJIkAKFFByb21wdE1vbml0b3JSZXF1ZXN0EigKBW1vZGVzGAEgAygOMhkuaXRlcm0yLlByb21wdE1vbml0b3JNb2RlIo0EChNOb3RpZmljYXRpb25SZXF1ZXN0Eg8KB3Nlc3Npb24YASABKAkSEQoJc3Vic2NyaWJlGAIgASgIEjMKEW5vdGlmaWNhdGlvbl90eXBlGAMgASgOMhguaXRlcm0yLk5vdGlmaWNhdGlvblR5cGUSQgoYcnBjX3JlZ2lzdHJhdGlvbl9yZXF1ZXN0GAQgASgLMh4uaXRlcm0yLlJQQ1JlZ2lzdHJhdGlvblJlcXVlc3RIABJEChlrZXlzdHJva2VfbW9uaXRvcl9yZXF1ZXN0GAUgASgLMh8uaXRlcm0yLktleXN0cm9rZU1vbml0b3JSZXF1ZXN0SAASQgoYdmFyaWFibGVfbW9uaXRvcl9yZXF1ZXN0GAYgASgLMh4uaXRlcm0yLlZhcmlhYmxlTW9uaXRvclJlcXVlc3RIABI+ChZwcm9maWxlX2NoYW5nZV9yZXF1ZXN0GAcgASgLMhwuaXRlcm0yLlByb2ZpbGVDaGFuZ2VSZXF1ZXN0SAASQgoYa2V5c3Ryb2tlX2ZpbHRlcl9yZXF1ZXN0GAggASgLMh4uaXRlcm0yLktleXN0cm9rZUZpbHRlclJlcXVlc3RIABI+ChZwcm9tcHRfbW9uaXRvcl9yZXF1ZXN0GAkgASgLMhwuaXRlcm0yLlByb21wdE1vbml0b3JSZXF1ZXN0SABCCwoJYXJndW1lbnRzIvUBChROb3RpZmljYXRpb25SZXNwb25zZRIzCgZzdGF0dXMYASABKA4yIy5pdGVybTIuTm90aWZpY2F0aW9uUmVzcG9uc2UuU3RhdHVzIqcBCgZTdGF0dXMSBgoCT0sQABIVChFTRVNTSU9OX05PVF9GT1VORBABEhUKEVJFUVVFU1RfTUFMRk9STUVEEAISEgoOTk9UX1NVQlNDUklCRUQQAxIWChJBTFJFQURZX1NVQlNDUklCRUQQBBIjCh9EVVBMSUNBVEVfU0VSVkVSX09SSUdJTkFURURfUlBDEAUSFgoSSU5WQUxJRF9JREVOVElGSUVSEAYiygcKDE5vdGlmaWNhdGlvbhI9ChZrZXlzdHJva2Vfbm90aWZpY2F0aW9uGAEgASgLMh0uaXRlcm0yLktleXN0cm9rZU5vdGlmaWNhdGlvbhJEChpzY3JlZW5fdXBkYXRlX25vdGlmaWNhdGlvbhgCIAEoCzIgLml0ZXJtMi5TY3JlZW5VcGRhdGVOb3RpZmljYXRpb24SNwoTcHJvbXB0X25vdGlmaWNhdGlvbhgDIAEoCzIaLml0ZXJtMi5Qcm9tcHROb3RpZmljYXRpb24STAocbG9jYXRpb25fY2hhbmdlX25vdGlmaWNhdGlvbhgEIAEoCzIiLml0ZXJtMi5Mb2NhdGlvbkNoYW5nZU5vdGlmaWNhdGlvbkICGAESVQojY3VzdG9tX2VzY2FwZV9zZXF1ZW5jZV9ub3RpZmljYXRpb24YBSABKAsyKC5pdGVybTIuQ3VzdG9tRXNjYXBlU2VxdWVuY2VOb3RpZmljYXRpb24SQAoYbmV3X3Nlc3Npb25fbm90aWZpY2F0aW9uGAYgASgLMh4uaXRlcm0yLk5ld1Nlc3Npb25Ob3RpZmljYXRpb24STAoedGVybWluYXRlX3Nlc3Npb25fbm90aWZpY2F0aW9uGAcgASgLMiQuaXRlcm0yLlRlcm1pbmF0ZVNlc3Npb25Ob3RpZmljYXRpb24SRgobbGF5b3V0X2NoYW5nZWRfbm90aWZpY2F0aW9uGAggASgLMiEuaXRlcm0yLkxheW91dENoYW5nZWROb3RpZmljYXRpb24SRAoaZm9jdXNfY2hhbmdlZF9ub3RpZmljYXRpb24YCSABKAsyIC5pdGVybTIuRm9jdXNDaGFuZ2VkTm90aWZpY2F0aW9uElMKInNlcnZlcl9vcmlnaW5hdGVkX3JwY19ub3RpZmljYXRpb24YCiABKAsyJy5pdGVybTIuU2VydmVyT3JpZ2luYXRlZFJQQ05vdGlmaWNhdGlvbhJOChlicm9hZGNhc3RfZG9tYWluc19jaGFuZ2VkGAsgASgLMisuaXRlcm0yLkJyb2FkY2FzdERvbWFpbnNDaGFuZ2VkTm90aWZpY2F0aW9uEkoKHXZhcmlhYmxlX2NoYW5nZWRfbm90aWZpY2F0aW9uGAwgASgLMiMuaXRlcm0yLlZhcmlhYmxlQ2hhbmdlZE5vdGlmaWNhdGlvbhJIChxwcm9maWxlX2NoYW5nZWRfbm90aWZpY2F0aW9uGA0gASgLMiIuaXRlcm0yLlByb2ZpbGVDaGFuZ2VkTm90aWZpY2F0aW9uIioKGlByb2ZpbGVDaGFuZ2VkTm90aWZpY2F0aW9uEgwKBGd1aWQYASABKAkifQobVmFyaWFibGVDaGFuZ2VkTm90aWZpY2F0aW9uEiQKBXNjb3BlGAEgASgOMhUuaXRlcm0yLlZhcmlhYmxlU2NvcGUSEgoKaWRlbnRpZmllchgCIAEoCRIMCgRuYW1lGAMgASgJEhYKDmpzb25fbmV3X3ZhbHVlGAQgASgJIlkKI0Jyb2FkY2FzdERvbWFpbnNDaGFuZ2VkTm90aWZpY2F0aW9uEjIKEWJyb2FkY2FzdF9kb21haW5zGAEgAygLMhcuaXRlcm0yLkJyb2FkY2FzdERvbWFpbiKQAQoTU2VydmVyT3JpZ2luYXRlZFJQQxIMCgRuYW1lGAIgASgJEjoKCWFyZ3VtZW50cxgDIAMoCzInLml0ZXJtMi5TZXJ2ZXJPcmlnaW5hdGVkUlBDLlJQQ0FyZ3VtZW50Gi8KC1JQQ0FyZ3VtZW50EgwKBG5hbWUYASABKAkSEgoKanNvbl92YWx1ZRgCIAEoCSJfCh9TZXJ2ZXJPcmlnaW5hdGVkUlBDTm90aWZpY2F0aW9uEhIKCnJlcXVlc3RfaWQYASABKAkSKAoDcnBjGAIgASgLMhsuaXRlcm0yLlNlcnZlck9yaWdpbmF0ZWRSUEMihQIKFUtleXN0cm9rZU5vdGlmaWNhdGlvbhISCgpjaGFyYWN0ZXJzGAEgASgJEiMKG2NoYXJhY3RlcnNJZ25vcmluZ01vZGlmaWVycxgCIAEoCRIkCgltb2RpZmllcnMYAyADKA4yES5pdGVybTIuTW9kaWZpZXJzEg8KB2tleUNvZGUYBCABKAUSDwoHc2Vzc2lvbhgFIAEoCRI0CgZhY3Rpb24YBiABKA4yJC5pdGVybTIuS2V5c3Ryb2tlTm90aWZpY2F0aW9uLkFjdGlvbiI1CgZBY3Rpb24SDAoIS0VZX0RPV04QABIKCgZLRVlfVVAQARIRCg1GTEFHU19DSEFOR0VEEAIiKwoYU2NyZWVuVXBkYXRlTm90aWZpY2F0aW9uEg8KB3Nlc3Npb24YASABKAkiWgoYUHJvbXB0Tm90aWZpY2F0aW9uUHJvbXB0EhMKC3BsYWNlaG9sZGVyGAEgASgJEikKBnByb21wdBgCIAEoCzIZLml0ZXJtMi5HZXRQcm9tcHRSZXNwb25zZSIxCh5Qcm9tcHROb3RpZmljYXRpb25Db21tYW5kU3RhcnQSDwoHY29tbWFuZBgBIAEoCSIuChxQcm9tcHROb3RpZmljYXRpb25Db21tYW5kRW5kEg4KBnN0YXR1cxgBIAEoBSL6AQoSUHJvbXB0Tm90aWZpY2F0aW9uEg8KB3Nlc3Npb24YASABKAkSMgoGcHJvbXB0GAIgASgLMiAuaXRlcm0yLlByb21wdE5vdGlmaWNhdGlvblByb21wdEgAEj8KDWNvbW1hbmRfc3RhcnQYAyABKAsyJi5pdGVybTIuUHJvbXB0Tm90aWZpY2F0aW9uQ29tbWFuZFN0YXJ0SAASOwoLY29tbWFuZF9lbmQYBCABKAsyJC5pdGVybTIuUHJvbXB0Tm90aWZpY2F0aW9uQ29tbWFuZEVuZEgAEhgKEHVuaXF1ZV9wcm9tcHRfaWQYBSABKAlCBwoFZXZlbnQiZgoaTG9jYXRpb25DaGFuZ2VOb3RpZmljYXRpb24SEQoJaG9zdF9uYW1lGAEgASgJEhEKCXVzZXJfbmFtZRgCIAEoCRIRCglkaXJlY3RvcnkYAyABKAkSDwoHc2Vzc2lvbhgEIAEoCSJdCiBDdXN0b21Fc2NhcGVTZXF1ZW5jZU5vdGlmaWNhdGlvbhIPCgdzZXNzaW9uGAEgASgJEhcKD3NlbmRlcl9pZGVudGl0eRgCIAEoCRIPCgdwYXlsb2FkGAMgASgJIiwKFk5ld1Nlc3Npb25Ob3RpZmljYXRpb24SEgoKc2Vzc2lvbl9pZBgBIAEoCSKEAwoYRm9jdXNDaGFuZ2VkTm90aWZpY2F0aW9uEhwKEmFwcGxpY2F0aW9uX2FjdGl2ZRgBIAEoCEgAEjkKBndpbmRvdxgCIAEoCzInLml0ZXJtMi5Gb2N1c0NoYW5nZWROb3RpZmljYXRpb24uV2luZG93SAASFgoMc2VsZWN0ZWRfdGFiGAMgASgJSAASEQoHc2Vzc2lvbhgEIAEoCUgAGtoBCgZXaW5kb3cSSwoNd2luZG93X3N0YXR1cxgBIAEoDjI0Lml0ZXJtMi5Gb2N1c0NoYW5nZWROb3RpZmljYXRpb24uV2luZG93LldpbmRvd1N0YXR1cxIRCgl3aW5kb3dfaWQYAiABKAkicAoMV2luZG93U3RhdHVzEh4KGlRFUk1JTkFMX1dJTkRPV19CRUNBTUVfS0VZEAASHgoaVEVSTUlOQUxfV0lORE9XX0lTX0NVUlJFTlQQARIgChxURVJNSU5BTF9XSU5ET1dfUkVTSUdORURfS0VZEAJCBwoFZXZlbnQiMgocVGVybWluYXRlU2Vzc2lvbk5vdGlmaWNhdGlvbhISCgpzZXNzaW9uX2lkGAEgASgJIlkKGUxheW91dENoYW5nZWROb3RpZmljYXRpb24SPAoWbGlzdF9zZXNzaW9uc19yZXNwb25zZRgBIAEoCzIcLml0ZXJtMi5MaXN0U2Vzc2lvbnNSZXNwb25zZSJiChBHZXRCdWZmZXJSZXF1ZXN0Eg8KB3Nlc3Npb24YASABKAkSJQoKbGluZV9yYW5nZRgCIAEoCzIRLml0ZXJtMi5MaW5lUmFuZ2USFgoOaW5jbHVkZV9zdHlsZXMYAyABKAgi6AIKEUdldEJ1ZmZlclJlc3BvbnNlEjQKBnN0YXR1cxgBIAEoDjIgLml0ZXJtMi5HZXRCdWZmZXJSZXNwb25zZS5TdGF0dXM6Ak9LEiAKBXJhbmdlGAIgASgLMg0uaXRlcm0yLlJhbmdlQgIYARImCghjb250ZW50cxgDIAMoCzIULml0ZXJtMi5MaW5lQ29udGVudHMSHQoGY3Vyc29yGAQgASgLMg0uaXRlcm0yLkNvb3JkEiIKFm51bV9saW5lc19hYm92ZV9zY3JlZW4YBSABKANCAhgBEjgKFHdpbmRvd2VkX2Nvb3JkX3JhbmdlGAYgASgLMhouaXRlcm0yLldpbmRvd2VkQ29vcmRSYW5nZSJWCgZTdGF0dXMSBgoCT0sQABIVChFTRVNTSU9OX05PVF9GT1VORBABEhYKEklOVkFMSURfTElORV9SQU5HRRACEhUKEVJFUVVFU1RfTUFMRk9STUVEEAMiPQoQR2V0UHJvbXB0UmVxdWVzdBIPCgdzZXNzaW9uGAEgASgJEhgKEHVuaXF1ZV9wcm9tcHRfaWQYAiABKAki4wMKEUdldFByb21wdFJlc3BvbnNlEjQKBnN0YXR1cxgBIAEoDjIgLml0ZXJtMi5HZXRQcm9tcHRSZXNwb25zZS5TdGF0dXM6Ak9LEigKDHByb21wdF9yYW5nZRgCIAEoCzISLml0ZXJtMi5Db29yZFJhbmdlEikKDWNvbW1hbmRfcmFuZ2UYAyABKAsyEi5pdGVybTIuQ29vcmRSYW5nZRIoCgxvdXRwdXRfcmFuZ2UYBCABKAsyEi5pdGVybTIuQ29vcmRSYW5nZRIZChF3b3JraW5nX2RpcmVjdG9yeRgFIAEoCRIPCgdjb21tYW5kGAYgASgJEjUKDHByb21wdF9zdGF0ZRgHIAEoDjIfLml0ZXJtMi5HZXRQcm9tcHRSZXNwb25zZS5TdGF0ZRITCgtleGl0X3N0YXR1cxgJIAEoDRIYChB1bmlxdWVfcHJvbXB0X2lkGAogASgJIlYKBlN0YXR1cxIGCgJPSxAAEhUKEVNFU1NJT05fTk9UX0ZPVU5EEAESFQoRUkVRVUVTVF9NQUxGT1JNRUQQAhIWChJQUk9NUFRfVU5BVkFJTEFCTEUQAyIvCgVTdGF0ZRILCgdFRElUSU5HEAASCwoHUlVOTklORxABEgwKCEZJTklTSEVEEAIiVgoSTGlzdFByb21wdHNSZXF1ZXN0Eg8KB3Nlc3Npb24YASABKAkSFwoPZmlyc3RfdW5pcXVlX2lkGAIgASgJEhYKDmxhc3RfdW5pcXVlX2lkGAMgASgJIpABChNMaXN0UHJvbXB0c1Jlc3BvbnNlEjYKBnN0YXR1cxgBIAEoDjIiLml0ZXJtMi5MaXN0UHJvbXB0c1Jlc3BvbnNlLlN0YXR1czoCT0sSGAoQdW5pcXVlX3Byb21wdF9pZBgCIAMoCSInCgZTdGF0dXMSBgoCT0sQABIVChFTRVNTSU9OX05PVF9GT1VORBABIjoKGUdldFByb2ZpbGVQcm9wZXJ0eVJlcXVlc3QSDwoHc2Vzc2lvbhgBIAEoCRIMCgRrZXlzGAIgAygJIjIKD1Byb2ZpbGVQcm9wZXJ0eRILCgNrZXkYASABKAkSEgoKanNvbl92YWx1ZRgCIAEoCSLTAQoaR2V0UHJvZmlsZVByb3BlcnR5UmVzcG9uc2USPQoGc3RhdHVzGAEgASgOMikuaXRlcm0yLkdldFByb2ZpbGVQcm9wZXJ0eVJlc3BvbnNlLlN0YXR1czoCT0sSKwoKcHJvcGVydGllcxgDIAMoCzIXLml0ZXJtMi5Qcm9maWxlUHJvcGVydHkiSQoGU3RhdHVzEgYKAk9LEAASFQoRU0VTU0lPTl9OT1RfRk9VTkQQARIVChFSRVFVRVNUX01BTEZPUk1FRBACEgkKBUVSUk9SEAMipwIKGVNldFByb2ZpbGVQcm9wZXJ0eVJlcXVlc3QSEQoHc2Vzc2lvbhgBIAEoCUgAEj8KCWd1aWRfbGlzdBgCIAEoCzIqLml0ZXJtMi5TZXRQcm9maWxlUHJvcGVydHlSZXF1ZXN0Lkd1aWRMaXN0SAASCwoDa2V5GAMgASgJEhIKCmpzb25fdmFsdWUYBCABKAkSQQoLYXNzaWdubWVudHMYBSADKAsyLC5pdGVybTIuU2V0UHJvZmlsZVByb3BlcnR5UmVxdWVzdC5Bc3NpZ25tZW50GhkKCEd1aWRMaXN0Eg0KBWd1aWRzGAEgAygJGi0KCkFzc2lnbm1lbnQSCwoDa2V5GAEgASgJEhIKCmpzb25fdmFsdWUYAiABKAlCCAoGdGFyZ2V0IqkBChpTZXRQcm9maWxlUHJvcGVydHlSZXNwb25zZRI9CgZzdGF0dXMYASABKA4yKS5pdGVybTIuU2V0UHJvZmlsZVByb3BlcnR5UmVzcG9uc2UuU3RhdHVzOgJPSyJMCgZTdGF0dXMSBgoCT0sQABIVChFTRVNTSU9OX05PVF9GT1VORBABEhUKEVJFUVVFU1RfTUFMRk9STUVEEAISDAoIQkFEX0dVSUQQAyIjChJUcmFuc2FjdGlvblJlcXVlc3QSDQoFYmVnaW4YASABKAgijwEKE1RyYW5zYWN0aW9uUmVzcG9uc2USNgoGc3RhdHVzGAEgASgOMiIuaXRlcm0yLlRyYW5zYWN0aW9uUmVzcG9uc2UuU3RhdHVzOgJPSyJACgZTdGF0dXMSBgoCT0sQABISCg5OT19UUkFOU0FDVElPThABEhoKFkFMUkVBRFlfSU5fVFJBTlNBQ1RJT04QAiJ7CglMaW5lUmFuZ2USHAoUc2NyZWVuX2NvbnRlbnRzX29ubHkYASABKAgSFgoOdHJhaWxpbmdfbGluZXMYAiABKAUSOAoUd2luZG93ZWRfY29vcmRfcmFuZ2UYAyABKAsyGi5pdGVybTIuV2luZG93ZWRDb29yZFJhbmdlIikKBVJhbmdlEhAKCGxvY2F0aW9uGAEgASgDEg4KBmxlbmd0aBgCIAEoAyJGCgpDb29yZFJhbmdlEhwKBXN0YXJ0GAEgASgLMg0uaXRlcm0yLkNvb3JkEhoKA2VuZBgCIAEoCzINLml0ZXJtMi5Db29yZCIdCgVDb29yZBIJCgF4GAEgASgFEgkKAXkYAiABKAMiNAoIUkdCQ29sb3ISCwoDcmVkGAEgASgNEg0KBWdyZWVuGAIgASgNEgwKBGJsdWUYAyABKA0iJgoDVVJMEgsKA3VybBgBIAEoCRISCgppZGVudGlmaWVyGAIgASgJIuEECglDZWxsU3R5bGUSFAoKZmdTdGFuZGFyZBgBIAEoDUgAEi0KC2ZnQWx0ZXJuYXRlGAIgASgOMhYuaXRlcm0yLkFsdGVybmF0ZUNvbG9ySAASIQoFZmdSZ2IYAyABKAsyEC5pdGVybTIuUkdCQ29sb3JIABIfChVmZ0FsdGVybmF0ZVBsYWNlbWVudFgYBCABKA1IABIUCgpiZ1N0YW5kYXJkGAUgASgNSAESLQoLYmdBbHRlcm5hdGUYBiABKA4yFi5pdGVybTIuQWx0ZXJuYXRlQ29sb3JIARIhCgViZ1JnYhgHIAEoCzIQLml0ZXJtMi5SR0JDb2xvckgBEh8KFWJnQWx0ZXJuYXRlUGxhY2VtZW50WRgIIAEoDUgBEgwKBGJvbGQYCSABKAgSDQoFZmFpbnQYCiABKAgSDgoGaXRhbGljGAsgASgIEg0KBWJsaW5rGAwgASgIEhEKCXVuZGVybGluZRgNIAEoCBIVCg1zdHJpa2V0aHJvdWdoGA4gASgIEhEKCWludmlzaWJsZRgPIAEoCBIPCgdpbnZlcnNlGBAgASgIEg8KB2d1YXJkZWQYESABKAgSKwoFaW1hZ2UYEiABKA4yHC5pdGVybTIuSW1hZ2VQbGFjZWhvbGRlclR5cGUSKAoOdW5kZXJsaW5lQ29sb3IYEyABKAsyEC5pdGVybTIuUkdCQ29sb3ISDwoHYmxvY2tJRBgUIAEoCRIYCgN1cmwYFSABKAsyCy5pdGVybTIuVVJMEg8KB3JlcGVhdHMYFiABKA1CCQoHZmdDb2xvckIJCgdiZ0NvbG9yIo0CCgxMaW5lQ29udGVudHMSDAoEdGV4dBgBIAEoCRI3ChRjb2RlX3BvaW50c19wZXJfY2VsbBgCIAMoCzIZLml0ZXJtMi5Db2RlUG9pbnRzUGVyQ2VsbBJOCgxjb250aW51YXRpb24YAyABKA4yIS5pdGVybTIuTGluZUNvbnRlbnRzLkNvbnRpbnVhdGlvbjoVQ09OVElOVUFUSU9OX0hBUkRfRU9MEiAKBXN0eWxlGAQgAygLMhEuaXRlcm0yLkNlbGxTdHlsZSJECgxDb250aW51YXRpb24SGQoVQ09OVElOVUFUSU9OX0hBUkRfRU9MEAESGQoVQ09OVElOVUFUSU9OX1NPRlRfRU9MEAIiQAoRQ29kZVBvaW50c1BlckNlbGwSGgoPbnVtX2NvZGVfcG9pbnRzGAEgASgFOgExEg8KB3JlcGVhdHMYAiABKAUiFQoTTGlzdFNlc3Npb25zUmVxdWVzdCJMCg9TZW5kVGV4dFJlcXVlc3QSDwoHc2Vzc2lvbhgBIAEoCRIMCgR0ZXh0GAIgASgJEhoKEnN1cHByZXNzX2Jyb2FkY2FzdBgDIAEoCCJsChBTZW5kVGV4dFJlc3BvbnNlEi8KBnN0YXR1cxgBIAEoDjIfLml0ZXJtMi5TZW5kVGV4dFJlc3BvbnNlLlN0YXR1cyInCgZTdGF0dXMSBgoCT0sQABIVChFTRVNTSU9OX05PVF9GT1VORBABIiUKBFNpemUSDQoFd2lkdGgYASABKAUSDgoGaGVpZ2h0GAIgASgFIh0KBVBvaW50EgkKAXgYASABKAUSCQoBeRgCIAEoBSJCCgVGcmFtZRIdCgZvcmlnaW4YASABKAsyDS5pdGVybTIuUG9pbnQSGgoEc2l6ZRgCIAEoCzIMLml0ZXJtMi5TaXplInkKDlNlc3Npb25TdW1tYXJ5EhkKEXVuaXF1ZV9pZGVudGlmaWVyGAEgASgJEhwKBWZyYW1lGAIgASgLMg0uaXRlcm0yLkZyYW1lEh8KCWdyaWRfc2l6ZRgDIAEoCzIMLml0ZXJtMi5TaXplEg0KBXRpdGxlGAQgASgJIsEBCg1TcGxpdFRyZWVOb2RlEhAKCHZlcnRpY2FsGAEgASgIEjIKBWxpbmtzGAIgAygLMiMuaXRlcm0yLlNwbGl0VHJlZU5vZGUuU3BsaXRUcmVlTGluaxpqCg1TcGxpdFRyZWVMaW5rEikKB3Nlc3Npb24YASABKAsyFi5pdGVybTIuU2Vzc2lvblN1bW1hcnlIABIlCgRub2RlGAIgASgLMhUuaXRlcm0yLlNwbGl0VHJlZU5vZGVIAEIHCgVjaGlsZCKdAwoUTGlzdFNlc3Npb25zUmVzcG9uc2USNAoHd2luZG93cxgBIAMoCzIjLml0ZXJtMi5MaXN0U2Vzc2lvbnNSZXNwb25zZS5XaW5kb3cSLwoPYnVyaWVkX3Nlc3Npb25zGAIgAygLMhYuaXRlcm0yLlNlc3Npb25TdW1tYXJ5GnkKBldpbmRvdxIuCgR0YWJzGAEgAygLMiAuaXRlcm0yLkxpc3RTZXNzaW9uc1Jlc3BvbnNlLlRhYhIRCgl3aW5kb3dfaWQYAiABKAkSHAoFZnJhbWUYAyABKAsyDS5pdGVybTIuRnJhbWUSDgoGbnVtYmVyGAQgASgFGqIBCgNUYWISIwoEcm9vdBgDIAEoCzIVLml0ZXJtMi5TcGxpdFRyZWVOb2RlEg4KBnRhYl9pZBgCIAEoCRIWCg50bXV4X3dpbmRvd19pZBgEIAEoCRIaChJ0bXV4X2Nvbm5lY3Rpb25faWQYBSABKAkSMgoSbWluaW1pemVkX3Nlc3Npb25zGAYgAygLMhYuaXRlcm0yLlNlc3Npb25TdW1tYXJ5Ip8BChBDcmVhdGVUYWJSZXF1ZXN0EhQKDHByb2ZpbGVfbmFtZRgBIAEoCRIRCgl3aW5kb3dfaWQYAiABKAkSEQoJdGFiX2luZGV4GAMgASgNEhMKB2NvbW1hbmQYBCABKAlCAhgBEjoKGWN1c3RvbV9wcm9maWxlX3Byb3BlcnRpZXMYBSADKAsyFy5pdGVybTIuUHJvZmlsZVByb3BlcnR5IvABChFDcmVhdGVUYWJSZXNwb25zZRIwCgZzdGF0dXMYASABKA4yIC5pdGVybTIuQ3JlYXRlVGFiUmVzcG9uc2UuU3RhdHVzEhEKCXdpbmRvd19pZBgCIAEoCRIOCgZ0YWJfaWQYAyABKAUSEgoKc2Vzc2lvbl9pZBgEIAEoCSJyCgZTdGF0dXMSBgoCT0sQABIYChRJTlZBTElEX1BST0ZJTEVfTkFNRRABEhUKEUlOVkFMSURfV0lORE9XX0lEEAISFQoRSU5WQUxJRF9UQUJfSU5ERVgQAxIYChRNSVNTSU5HX1NVQlNUSVRVVElPThAEIv4BChBTcGxpdFBhbmVSZXF1ZXN0Eg8KB3Nlc3Npb24YASABKAkSQAoPc3BsaXRfZGlyZWN0aW9uGAIgASgOMicuaXRlcm0yLlNwbGl0UGFuZVJlcXVlc3QuU3BsaXREaXJlY3Rpb24SFQoGYmVmb3JlGAMgASgIOgVmYWxzZRIUCgxwcm9maWxlX25hbWUYBCABKAkSOgoZY3VzdG9tX3Byb2ZpbGVfcHJvcGVydGllcxgFIAMoCzIXLml0ZXJtMi5Qcm9maWxlUHJvcGVydHkiLgoOU3BsaXREaXJlY3Rpb24SDAoIVkVSVElDQUwQABIOCgpIT1JJWk9OVEFMEAEi1QEKEVNwbGl0UGFuZVJlc3BvbnNlEjAKBnN0YXR1cxgBIAEoDjIgLml0ZXJtMi5TcGxpdFBhbmVSZXNwb25zZS5TdGF0dXMSEgoKc2Vzc2lvbl9pZBgCIAMoCSJ6CgZTdGF0dXMSBgoCT0sQABIVChFTRVNTSU9OX05PVF9GT1VORBABEhgKFElOVkFMSURfUFJPRklMRV9OQU1FEAISEAoMQ0FOTk9UX1NQTElUEAMSJQohTUFMRk9STUVEX0NVU1RPTV9QUk9GSUxFX1BST1BFUlRZEAQqVgoNU2VsZWN0aW9uTW9kZRINCglDSEFSQUNURVIQABIICgRXT1JEEAESCAoETElORRACEgkKBVNNQVJUEAMSBwoDQk9YEAQSDgoKV0hPTEVfTElORRAFKrQDChBOb3RpZmljYXRpb25UeXBlEhcKE05PVElGWV9PTl9LRVlTVFJPS0UQARIbChdOT1RJRllfT05fU0NSRUVOX1VQREFURRACEhQKEE5PVElGWV9PTl9QUk9NUFQQAxIhChlOT1RJRllfT05fTE9DQVRJT05fQ0hBTkdFEAQaAggBEiQKIE5PVElGWV9PTl9DVVNUT01fRVNDQVBFX1NFUVVFTkNFEAUSHQoZTk9USUZZX09OX1ZBUklBQkxFX0NIQU5HRRAMEhQKEEtFWVNUUk9LRV9GSUxURVIQDhIZChVOT1RJRllfT05fTkVXX1NFU1NJT04QBhIfChtOT1RJRllfT05fVEVSTUlOQVRFX1NFU1NJT04QBxIbChdOT1RJRllfT05fTEFZT1VUX0NIQU5HRRAIEhoKFk5PVElGWV9PTl9GT0NVU19DSEFOR0UQCRIjCh9OT1RJRllfT05fU0VSVkVSX09SSUdJTkFURURfUlBDEAoSHgoaTk9USUZZX09OX0JST0FEQ0FTVF9DSEFOR0UQCxIcChhOT1RJRllfT05fUFJPRklMRV9DSEFOR0UQDSpWCglNb2RpZmllcnMSCwoHQ09OVFJPTBABEgoKBk9QVElPThACEgsKB0NPTU1BTkQQAxIJCgVTSElGVBAEEgwKCEZVTkNUSU9OEAUSCgoGTlVNUEFEEAYqOgoNVmFyaWFibGVTY29wZRILCgdTRVNTSU9OEAESBwoDVEFCEAISCgoGV0lORE9XEAMSBwoDQVBQEAQqQwoRUHJvbXB0TW9uaXRvck1vZGUSCgoGUFJPTVBUEAESEQoNQ09NTUFORF9TVEFSVBACEg8KC0NPTU1BTkRfRU5EEAMqRwoOQWx0ZXJuYXRlQ29sb3ISCwoHREVGQVVMVBAAEhQKEFJFVkVSU0VEX0RFRkFVTFQQAxISCg5TWVNURU1fTUVTU0FHRRAEKjcKFEltYWdlUGxhY2Vob2xkZXJUeXBlEggKBE5PTkUQABIKCgZJVEVSTTIQARIJCgVLSVRUWRACQgaiAgNJVE0");
+var ClientOriginatedMessageSchema = /* @__PURE__ */ messageDesc(file_api, 0);
+var ServerOriginatedMessageSchema = /* @__PURE__ */ messageDesc(file_api, 1);
+var CloseRequestSchema = /* @__PURE__ */ messageDesc(file_api, 4);
+var CloseRequest_CloseTabsSchema = /* @__PURE__ */ messageDesc(file_api, 4, 0);
+var CloseRequest_CloseSessionsSchema = /* @__PURE__ */ messageDesc(file_api, 4, 1);
+var CloseRequest_CloseWindowsSchema = /* @__PURE__ */ messageDesc(file_api, 4, 2);
+var RestartSessionRequestSchema = /* @__PURE__ */ messageDesc(file_api, 30);
+var ListProfilesRequestSchema = /* @__PURE__ */ messageDesc(file_api, 34);
+var FocusRequestSchema = /* @__PURE__ */ messageDesc(file_api, 36);
+var VariableRequestSchema = /* @__PURE__ */ messageDesc(file_api, 40);
+var VariableRequest_SetSchema = /* @__PURE__ */ messageDesc(file_api, 40, 0);
+var ActivateRequestSchema = /* @__PURE__ */ messageDesc(file_api, 42);
+var InjectRequestSchema = /* @__PURE__ */ messageDesc(file_api, 44);
+var GetPropertyRequestSchema = /* @__PURE__ */ messageDesc(file_api, 46);
+var SetPropertyRequestSchema = /* @__PURE__ */ messageDesc(file_api, 48);
+var NotificationRequestSchema = /* @__PURE__ */ messageDesc(file_api, 59);
+var GetBufferRequestSchema = /* @__PURE__ */ messageDesc(file_api, 79);
+var GetProfilePropertyRequestSchema = /* @__PURE__ */ messageDesc(file_api, 85);
+var SetProfilePropertyRequestSchema = /* @__PURE__ */ messageDesc(file_api, 88);
+var LineRangeSchema = /* @__PURE__ */ messageDesc(file_api, 92);
+var ListSessionsRequestSchema = /* @__PURE__ */ messageDesc(file_api, 101);
+var SendTextRequestSchema = /* @__PURE__ */ messageDesc(file_api, 102);
+var CreateTabRequestSchema = /* @__PURE__ */ messageDesc(file_api, 110);
+var SplitPaneRequestSchema = /* @__PURE__ */ messageDesc(file_api, 112);
+var UNIX_SOCKET_PATH = join(
+  homedir(),
+  "Library",
+  "Application Support",
+  "iTerm2",
+  "private",
+  "socket"
+);
+var TCP_URL = "ws://localhost:1912";
+var resolveTransport = () => {
+  if (existsSync(UNIX_SOCKET_PATH)) {
+    return {
+      url: "ws://localhost",
+      socketPath: UNIX_SOCKET_PATH
+    };
+  }
+  return { url: TCP_URL };
+};
+
+// src/connection/connection.ts
+var Connection = class _Connection {
+  ws = null;
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  notificationHandlers = /* @__PURE__ */ new Set();
+  closed = false;
+  static async create(options = {}) {
+    const conn = new _Connection();
+    await conn.connect(options);
+    return conn;
+  }
+  async connect(options) {
+    const transport = options.transport ?? resolveTransport();
+    const headers = options.headers ?? buildHeaders(options.advisoryName ?? "iterm2-ts", options.disableAuthUi);
+    return new Promise((resolve, reject) => {
+      const { socketPath } = transport;
+      const wsOptions = {
+        headers: { ...headers },
+        ...socketPath ? { createConnection: () => net.connect(socketPath) } : {}
+      };
+      this.ws = new WebSocket(transport.url, ["api.iterm2.com"], wsOptions);
+      this.ws.binaryType = "nodebuffer";
+      this.ws.on("open", () => resolve());
+      this.ws.on("error", (err) => {
+        if (!this.ws || this.ws.readyState === WebSocket.CONNECTING) {
+          reject(err);
+        }
+        this.rejectAllPending(err);
+      });
+      this.ws.on("close", () => {
+        this.closed = true;
+        this.rejectAllPending(new Error("Connection closed"));
+      });
+      this.ws.on("message", (data) => {
+        this.handleMessage(data);
+      });
+    });
+  }
+  send(submessage) {
+    if (this.closed || !this.ws) {
+      return Promise.reject(new Error("Connection is closed"));
+    }
+    const id = this.nextId++;
+    const request = create(ClientOriginatedMessageSchema, {
+      id: BigInt(id),
+      submessage
+    });
+    const encoded = toBinary(ClientOriginatedMessageSchema, request);
+    this.ws.send(encoded);
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+    });
+  }
+  onNotification(handler) {
+    this.notificationHandlers.add(handler);
+    return () => {
+      this.notificationHandlers.delete(handler);
+    };
+  }
+  close() {
+    this.closed = true;
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.rejectAllPending(new Error("Connection closed by client"));
+  }
+  get isConnected() {
+    return !this.closed && this.ws?.readyState === WebSocket.OPEN;
+  }
+  handleMessage(data) {
+    const message = fromBinary(ServerOriginatedMessageSchema, new Uint8Array(data));
+    if (message.submessage.case === "notification") {
+      for (const handler of this.notificationHandlers) {
+        handler(message.submessage.value);
+      }
+      return;
+    }
+    const id = message.id;
+    if (id === 0n) return;
+    const idNum = Number(id);
+    const pending = this.pending.get(idNum);
+    if (pending) {
+      this.pending.delete(idNum);
+      if (message.submessage.case === "error") {
+        pending.reject(new Error(`iTerm2 error: ${message.submessage.value}`));
+      } else {
+        pending.resolve(message);
+      }
+    }
+  }
+  rejectAllPending(err) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    for (const [id, pending] of this.pending) {
+      pending.reject(error);
+      this.pending.delete(id);
+    }
+  }
+};
+
+// src/events/emitter.ts
+var TypedEmitter = class {
+  handlers = /* @__PURE__ */ new Map();
+  on(event, handler) {
+    let set = this.handlers.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.handlers.set(event, set);
+    }
+    set.add(handler);
+    return () => this.off(event, handler);
+  }
+  off(event, handler) {
+    const set = this.handlers.get(event);
+    if (set) {
+      set.delete(handler);
+      if (set.size === 0) {
+        this.handlers.delete(event);
+      }
+    }
+  }
+  emit(event, data) {
+    const set = this.handlers.get(event);
+    if (set) {
+      for (const handler of set) {
+        handler(data);
+      }
+    }
+  }
+  hasListeners(event) {
+    return (this.handlers.get(event)?.size ?? 0) > 0;
+  }
+  removeAllListeners() {
+    this.handlers.clear();
+  }
+};
+var NOTIFICATION_MAPPINGS = [
+  ["newSessionNotification", "sessionCreated"],
+  ["terminateSessionNotification", "sessionTerminated"],
+  ["layoutChangedNotification", "layoutChanged"],
+  ["focusChangedNotification", "focusChanged"],
+  ["screenUpdateNotification", "screenUpdated"],
+  ["keystrokeNotification", "keystroke"],
+  ["customEscapeSequenceNotification", "customEscapeSequence"],
+  ["variableChangedNotification", "variableChanged"],
+  ["profileChangedNotification", "profileChanged"],
+  ["broadcastDomainsChanged", "broadcastDomainsChanged"],
+  ["promptNotification", "prompt"]
+];
+var dispatchNotification = (emitter, notification) => {
+  for (const [key, event] of NOTIFICATION_MAPPINGS) {
+    const value = notification[key];
+    if (value) {
+      emitter.emit(event, value);
+    }
+  }
+};
+
+// src/events/iterator.ts
+var createAsyncIterator = (emitter, event) => {
+  const buffer = [];
+  let resolve = null;
+  let done = false;
+  const handler = (data) => {
+    if (resolve) {
+      const r = resolve;
+      resolve = null;
+      r({ value: data, done: false });
+    } else {
+      buffer.push(data);
+    }
+  };
+  const cleanup = emitter.on(event, handler);
+  return {
+    next() {
+      if (done) {
+        return Promise.resolve({ value: void 0, done: true });
+      }
+      const buffered = buffer.shift();
+      if (buffered !== void 0) {
+        return Promise.resolve({ value: buffered, done: false });
+      }
+      return new Promise((r) => {
+        resolve = r;
+      });
+    },
+    return() {
+      done = true;
+      cleanup();
+      if (resolve) {
+        resolve({ value: void 0, done: true });
+        resolve = null;
+      }
+      return Promise.resolve({ value: void 0, done: true });
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    }
+  };
+};
+var EVENT_TO_NOTIFICATION_TYPE = {
+  sessionCreated: 6 /* NOTIFY_ON_NEW_SESSION */,
+  sessionTerminated: 7 /* NOTIFY_ON_TERMINATE_SESSION */,
+  layoutChanged: 8 /* NOTIFY_ON_LAYOUT_CHANGE */,
+  focusChanged: 9 /* NOTIFY_ON_FOCUS_CHANGE */,
+  screenUpdated: 2 /* NOTIFY_ON_SCREEN_UPDATE */,
+  keystroke: 1 /* NOTIFY_ON_KEYSTROKE */,
+  customEscapeSequence: 5 /* NOTIFY_ON_CUSTOM_ESCAPE_SEQUENCE */,
+  variableChanged: 12 /* NOTIFY_ON_VARIABLE_CHANGE */,
+  profileChanged: 13 /* NOTIFY_ON_PROFILE_CHANGE */,
+  broadcastDomainsChanged: 11 /* NOTIFY_ON_BROADCAST_CHANGE */,
+  prompt: 3 /* NOTIFY_ON_PROMPT */
+};
+var subscribe = async (conn, event, sessionId) => {
+  const notificationType = EVENT_TO_NOTIFICATION_TYPE[event];
+  const response = await conn.send({
+    case: "notificationRequest",
+    value: create(NotificationRequestSchema, {
+      subscribe: true,
+      notificationType,
+      session: sessionId
+    })
+  });
+  if (response.submessage.case === "notificationResponse") {
+    const status = response.submessage.value.status;
+    if (status !== 0 /* OK */ && status !== 4 /* ALREADY_SUBSCRIBED */) {
+      throw new Error(`subscribe to ${event} failed: status ${status}`);
+    }
+  }
+};
+var unsubscribe = async (conn, event, sessionId) => {
+  const notificationType = EVENT_TO_NOTIFICATION_TYPE[event];
+  const response = await conn.send({
+    case: "notificationRequest",
+    value: create(NotificationRequestSchema, {
+      subscribe: false,
+      notificationType,
+      session: sessionId
+    })
+  });
+  if (response.submessage.case === "notificationResponse") {
+    const status = response.submessage.value.status;
+    if (status !== 0 /* OK */ && status !== 3 /* NOT_SUBSCRIBED */) {
+      throw new Error(`unsubscribe from ${event} failed: status ${status}`);
+    }
+  }
+};
+
+// src/models/common.ts
+var pointFromProto = (p) => ({
+  x: p?.x ?? 0,
+  y: p?.y ?? 0
+});
+var sizeFromProto = (s) => ({
+  width: s?.width ?? 0,
+  height: s?.height ?? 0
+});
+var frameFromProto = (f) => ({
+  origin: pointFromProto(f?.origin),
+  size: sizeFromProto(f?.size)
+});
+var profilePropertyFromProto = (p) => ({
+  key: p.key ?? "",
+  value: p.jsonValue ? JSON.parse(p.jsonValue) : null
+});
+
+// src/models/session.ts
+var sessionFromProto = (s) => ({
+  id: s.uniqueIdentifier ?? "",
+  name: s.title ?? "",
+  frame: s.frame ? frameFromProto(s.frame) : void 0,
+  gridSize: s.gridSize ? sizeFromProto(s.gridSize) : void 0
+});
+
+// src/models/tab.ts
+var collectSessions = (node) => {
+  if (!node?.links) return [];
+  const sessions = [];
+  for (const link of node.links) {
+    if (link.child.case === "session") {
+      sessions.push(sessionFromProto(link.child.value));
+    }
+    if (link.child.case === "node") {
+      sessions.push(...collectSessions(link.child.value));
+    }
+  }
+  return sessions;
+};
+var tabFromProto = (t) => ({
+  id: t.tabId ?? "",
+  sessions: collectSessions(t.root)
+});
+
+// src/models/window.ts
+var windowFromProto = (w) => ({
+  id: w.windowId ?? "",
+  tabs: (w.tabs ?? []).map(tabFromProto),
+  frame: w.frame ? frameFromProto(w.frame) : void 0,
+  number: w.number ?? void 0
+});
+
+// src/models/app.ts
+var appFromProto = (response) => ({
+  windows: (response.windows ?? []).map(windowFromProto),
+  buriedSessions: (response.buriedSessions ?? []).map(sessionFromProto)
+});
+var listProfiles = async (conn, properties, guids) => {
+  const response = await conn.send({
+    case: "listProfilesRequest",
+    value: create(ListProfilesRequestSchema, {
+      properties: properties ? [...properties] : [],
+      guids: guids ? [...guids] : []
+    })
+  });
+  if (response.submessage.case !== "listProfilesResponse") {
+    return [];
+  }
+  const profiles = response.submessage.value.profiles;
+  return profiles.map((p) => {
+    const props = p.properties.map(profilePropertyFromProto);
+    const guidProp = props.find((prop) => prop.key === "Guid");
+    const nameProp = props.find((prop) => prop.key === "Name");
+    return {
+      guid: guidProp?.value ?? "",
+      name: nameProp?.value ?? "",
+      properties: props
+    };
+  });
+};
+var getProfileProperty = async (conn, sessionId, key) => {
+  const response = await conn.send({
+    case: "getProfilePropertyRequest",
+    value: create(GetProfilePropertyRequestSchema, {
+      session: sessionId,
+      keys: [key]
+    })
+  });
+  if (response.submessage.case !== "getProfilePropertyResponse") {
+    return null;
+  }
+  const propResponse = response.submessage.value;
+  if (propResponse.status !== 0 /* OK */) {
+    throw new Error(`getProfileProperty failed: status ${propResponse.status}`);
+  }
+  const prop = propResponse.properties[0];
+  return prop?.jsonValue ? JSON.parse(prop.jsonValue) : null;
+};
+var setProfileProperty = async (conn, sessionId, key, value) => {
+  const response = await conn.send({
+    case: "setProfilePropertyRequest",
+    value: create(SetProfilePropertyRequestSchema, {
+      target: { case: "session", value: sessionId },
+      key,
+      jsonValue: JSON.stringify(value)
+    })
+  });
+  if (response.submessage.case === "setProfilePropertyResponse" && response.submessage.value.status !== 0 /* OK */) {
+    throw new Error(`setProfileProperty failed: status ${response.submessage.value.status}`);
+  }
+};
+var sendText = async (conn, sessionId, text, suppressBroadcast) => {
+  const response = await conn.send({
+    case: "sendTextRequest",
+    value: create(SendTextRequestSchema, {
+      session: sessionId,
+      text,
+      suppressBroadcast
+    })
+  });
+  if (response.submessage.case === "sendTextResponse" && response.submessage.value.status !== 0 /* OK */) {
+    throw new Error(`sendText failed: status ${response.submessage.value.status}`);
+  }
+};
+var splitPane = async (conn, sessionId, options = {}) => {
+  const direction = options.direction === "horizontal" ? 1 /* HORIZONTAL */ : 0 /* VERTICAL */;
+  const response = await conn.send({
+    case: "splitPaneRequest",
+    value: create(SplitPaneRequestSchema, {
+      session: sessionId,
+      splitDirection: direction,
+      before: options.before,
+      profileName: options.profile
+    })
+  });
+  if (response.submessage.case !== "splitPaneResponse") {
+    throw new Error("splitPane: unexpected response");
+  }
+  const splitResponse = response.submessage.value;
+  if (splitResponse.status !== 0 /* OK */) {
+    throw new Error(`splitPane failed: status ${splitResponse.status}`);
+  }
+  const newSessionId = splitResponse.sessionId[0];
+  if (!newSessionId) {
+    throw new Error("splitPane: no session ID returned");
+  }
+  return { id: newSessionId, name: "" };
+};
+var getScreenContents = async (conn, sessionId) => {
+  const response = await conn.send({
+    case: "getBufferRequest",
+    value: create(GetBufferRequestSchema, {
+      session: sessionId,
+      lineRange: create(LineRangeSchema, { screenContentsOnly: true })
+    })
+  });
+  if (response.submessage.case !== "getBufferResponse") {
+    throw new Error("getScreenContents: unexpected response");
+  }
+  const bufferResponse = response.submessage.value;
+  if (bufferResponse.status !== 0 /* OK */) {
+    throw new Error(`getScreenContents failed: status ${bufferResponse.status}`);
+  }
+  return bufferResponse.contents.map((line) => line.text ?? "").join("\n");
+};
+var getBuffer = async (conn, sessionId, trailingLines) => {
+  const lineRange = trailingLines != null ? create(LineRangeSchema, { trailingLines }) : create(LineRangeSchema, { screenContentsOnly: true });
+  const response = await conn.send({
+    case: "getBufferRequest",
+    value: create(GetBufferRequestSchema, {
+      session: sessionId,
+      lineRange
+    })
+  });
+  if (response.submessage.case !== "getBufferResponse") {
+    throw new Error("getBuffer: unexpected response");
+  }
+  const bufferResponse = response.submessage.value;
+  if (bufferResponse.status !== 0 /* OK */) {
+    throw new Error(`getBuffer failed: status ${bufferResponse.status}`);
+  }
+  return bufferResponse.contents.map((line) => ({
+    text: line.text ?? "",
+    continuation: line.continuation === 2 /* SOFT_EOL */ ? "soft" : "hard"
+  }));
+};
+var inject = async (conn, sessionId, data) => {
+  const response = await conn.send({
+    case: "injectRequest",
+    value: create(InjectRequestSchema, {
+      sessionId: [sessionId],
+      data
+    })
+  });
+  if (response.submessage.case === "injectResponse") {
+    const status = response.submessage.value.status[0];
+    if (status != null && status !== 0 /* OK */) {
+      throw new Error(`inject failed: status ${status}`);
+    }
+  }
+};
+var restartSession = async (conn, sessionId, onlyIfExited) => {
+  const response = await conn.send({
+    case: "restartSessionRequest",
+    value: create(RestartSessionRequestSchema, {
+      sessionId,
+      onlyIfExited
+    })
+  });
+  if (response.submessage.case === "restartSessionResponse" && response.submessage.value.status !== 0 /* OK */) {
+    throw new Error(`restartSession failed: status ${response.submessage.value.status}`);
+  }
+};
+var createTab = async (conn, windowId, profile) => {
+  const response = await conn.send({
+    case: "createTabRequest",
+    value: create(CreateTabRequestSchema, {
+      windowId,
+      profileName: profile
+    })
+  });
+  if (response.submessage.case !== "createTabResponse") {
+    throw new Error("createTab: unexpected response");
+  }
+  const tabResponse = response.submessage.value;
+  if (tabResponse.status !== 0 /* OK */) {
+    throw new Error(`createTab failed: status ${tabResponse.status}`);
+  }
+  return {
+    windowId: tabResponse.windowId ?? "",
+    tabId: String(tabResponse.tabId ?? ""),
+    sessionId: tabResponse.sessionId ?? ""
+  };
+};
+var createWindow = async (conn, profile) => {
+  return createTab(conn, void 0, profile);
+};
+var activate = async (conn, target) => {
+  const identifierMap = {
+    session: "sessionId",
+    tab: "tabId",
+    window: "windowId"
+  };
+  const response = await conn.send({
+    case: "activateRequest",
+    value: create(ActivateRequestSchema, {
+      orderWindowFront: true,
+      selectTab: true,
+      selectSession: true,
+      identifier: { case: identifierMap[target.type], value: target.id }
+    })
+  });
+  if (response.submessage.case === "activateResponse" && response.submessage.value.status !== 0 /* OK */) {
+    throw new Error(`activate failed: status ${response.submessage.value.status}`);
+  }
+};
+var close = async (conn, target, force) => {
+  let closeTarget;
+  switch (target.type) {
+    case "session":
+      closeTarget = {
+        case: "sessions",
+        value: create(CloseRequest_CloseSessionsSchema, { sessionIds: [...target.ids] })
+      };
+      break;
+    case "tab":
+      closeTarget = {
+        case: "tabs",
+        value: create(CloseRequest_CloseTabsSchema, { tabIds: [...target.ids] })
+      };
+      break;
+    case "window":
+      closeTarget = {
+        case: "windows",
+        value: create(CloseRequest_CloseWindowsSchema, { windowIds: [...target.ids] })
+      };
+      break;
+  }
+  const response = await conn.send({
+    case: "closeRequest",
+    value: create(CloseRequestSchema, {
+      force,
+      target: closeTarget
+    })
+  });
+  if (response.submessage.case === "closeResponse") {
+    for (const status of response.submessage.value.statuses) {
+      if (status !== 0 /* OK */) {
+        throw new Error(`close failed: status ${status}`);
+      }
+    }
+  }
+};
+
+// src/api/client.ts
+var ITerm2 = class _ITerm2 {
+  conn;
+  emitter = new TypedEmitter();
+  subscriptions = /* @__PURE__ */ new Set();
+  cleanupNotificationHandler = null;
+  constructor(connection) {
+    this.conn = connection;
+    this.cleanupNotificationHandler = this.conn.onNotification(
+      (notification) => dispatchNotification(this.emitter, notification)
+    );
+  }
+  static async connect(options = {}) {
+    const conn = await Connection.create(options);
+    return new _ITerm2(conn);
+  }
+  get connection() {
+    return this.conn;
+  }
+  // --- App ---
+  async getApp() {
+    const response = await this.conn.send({
+      case: "listSessionsRequest",
+      value: create(ListSessionsRequestSchema, {})
+    });
+    if (response.submessage.case !== "listSessionsResponse") {
+      throw new Error("getApp: no response");
+    }
+    return appFromProto(response.submessage.value);
+  }
+  // --- Sessions ---
+  async sendText(sessionId, text, suppressBroadcast) {
+    return sendText(this.conn, sessionId, text, suppressBroadcast);
+  }
+  async splitPane(sessionId, options) {
+    return splitPane(this.conn, sessionId, options);
+  }
+  async getScreenContents(sessionId) {
+    return getScreenContents(this.conn, sessionId);
+  }
+  async getBuffer(sessionId, trailingLines) {
+    return getBuffer(this.conn, sessionId, trailingLines);
+  }
+  async inject(sessionId, data) {
+    return inject(this.conn, sessionId, data);
+  }
+  async restartSession(sessionId, onlyIfExited) {
+    return restartSession(this.conn, sessionId, onlyIfExited);
+  }
+  // --- Windows & Tabs ---
+  async createTab(windowId, profile) {
+    return createTab(this.conn, windowId, profile);
+  }
+  async createWindow(profile) {
+    return createWindow(this.conn, profile);
+  }
+  async activate(target) {
+    return activate(this.conn, target);
+  }
+  async close(target, force) {
+    return close(this.conn, target, force);
+  }
+  // --- Profiles ---
+  async listProfiles(properties, guids) {
+    return listProfiles(this.conn, properties, guids);
+  }
+  async getProfileProperty(sessionId, key) {
+    return getProfileProperty(this.conn, sessionId, key);
+  }
+  async setProfileProperty(sessionId, key, value) {
+    return setProfileProperty(this.conn, sessionId, key, value);
+  }
+  // --- Variables ---
+  async setVariable(sessionId, name, value) {
+    const response = await this.conn.send({
+      case: "variableRequest",
+      value: create(VariableRequestSchema, {
+        scope: { case: "sessionId", value: sessionId },
+        set: [create(VariableRequest_SetSchema, { name, value: JSON.stringify(value) })]
+      })
+    });
+    if (response.submessage.case === "variableResponse" && response.submessage.value.status !== 0 /* OK */) {
+      throw new Error(`setVariable failed: status ${response.submessage.value.status}`);
+    }
+  }
+  async getVariable(sessionId, name) {
+    const response = await this.conn.send({
+      case: "variableRequest",
+      value: create(VariableRequestSchema, {
+        scope: { case: "sessionId", value: sessionId },
+        get: [name]
+      })
+    });
+    if (response.submessage.case !== "variableResponse") {
+      return null;
+    }
+    const varResponse = response.submessage.value;
+    if (varResponse.status !== 0 /* OK */) {
+      throw new Error(`getVariable failed: status ${varResponse.status}`);
+    }
+    const val = varResponse.values[0];
+    return val ? JSON.parse(val) : null;
+  }
+  // --- Properties ---
+  async setProperty(name, windowId, value) {
+    const response = await this.conn.send({
+      case: "setPropertyRequest",
+      value: create(SetPropertyRequestSchema, {
+        identifier: { case: "windowId", value: windowId },
+        name,
+        jsonValue: JSON.stringify(value)
+      })
+    });
+    if (response.submessage.case === "setPropertyResponse" && response.submessage.value.status !== 0 /* OK */) {
+      throw new Error(`setProperty failed: status ${response.submessage.value.status}`);
+    }
+  }
+  async getProperty(name, windowId) {
+    const response = await this.conn.send({
+      case: "getPropertyRequest",
+      value: create(GetPropertyRequestSchema, {
+        identifier: { case: "windowId", value: windowId },
+        name
+      })
+    });
+    if (response.submessage.case !== "getPropertyResponse") {
+      return null;
+    }
+    const propResponse = response.submessage.value;
+    if (propResponse.status !== 0 /* OK */) {
+      throw new Error(`getProperty failed: status ${propResponse.status}`);
+    }
+    return propResponse.jsonValue ? JSON.parse(propResponse.jsonValue) : null;
+  }
+  // --- Focus ---
+  async focus() {
+    const response = await this.conn.send({
+      case: "focusRequest",
+      value: create(FocusRequestSchema, {})
+    });
+    if (response.submessage.case !== "focusResponse") {
+      return [];
+    }
+    return response.submessage.value.notifications;
+  }
+  // --- Events ---
+  async on(event, handler, sessionId) {
+    const subKey = `${event}:${sessionId ?? ""}`;
+    if (!this.subscriptions.has(subKey)) {
+      await subscribe(this.conn, event, sessionId);
+      this.subscriptions.add(subKey);
+    }
+    const cleanup = this.emitter.on(event, handler);
+    return async () => {
+      cleanup();
+      if (!this.emitter.hasListeners(event)) {
+        this.subscriptions.delete(subKey);
+        await unsubscribe(this.conn, event, sessionId).catch(() => {
+        });
+      }
+    };
+  }
+  async *notifications(event, sessionId) {
+    const subKey = `${event}:${sessionId ?? ""}`;
+    if (!this.subscriptions.has(subKey)) {
+      await subscribe(this.conn, event, sessionId);
+      this.subscriptions.add(subKey);
+    }
+    const iterator = createAsyncIterator(this.emitter, event);
+    try {
+      yield* iterator;
+    } finally {
+      iterator.return?.();
+      if (!this.emitter.hasListeners(event)) {
+        this.subscriptions.delete(subKey);
+        await unsubscribe(this.conn, event, sessionId).catch(() => {
+        });
+      }
+    }
+  }
+  // --- Raw notification handler ---
+  onNotification(handler) {
+    return this.conn.onNotification(handler);
+  }
+  // --- Lifecycle ---
+  disconnect() {
+    this.emitter.removeAllListeners();
+    this.cleanupNotificationHandler?.();
+    this.cleanupNotificationHandler = null;
+    this.subscriptions.clear();
+    this.conn.close();
+  }
+  get isConnected() {
+    return this.conn.isConnected;
+  }
+};
+
+// src/index.ts
+var connect = (options) => ITerm2.connect(options);
+
+export { ITerm2, connect };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map