@mtcute/convert 0.16.0 → 0.16.9

package/index.js

@@ -1 +1,488 @@
-export * from './esm/index.js'
+import { dataViewFromBuffer, readStringSession, TlBinaryReader, TlBinaryWriter, longFromBuffer } from "@mtcute/core/utils.js";
+import { MtArgumentError, Long } from "@mtcute/core";
+import { getPlatform } from "@mtcute/core/platform.js";
+const DC_MAPPING_PROD = {
+  1: {
+    main: {
+      id: 1,
+      ipAddress: "149.154.175.56",
+      port: 443
+    },
+    media: {
+      id: 1,
+      ipAddress: "149.154.175.211",
+      port: 443
+    }
+  },
+  2: {
+    main: {
+      id: 2,
+      ipAddress: "149.154.167.41",
+      port: 443
+    },
+    media: {
+      id: 2,
+      ipAddress: "149.154.167.35",
+      port: 443
+    }
+  },
+  3: {
+    main: {
+      id: 3,
+      ipAddress: "149.154.175.100",
+      port: 443
+    },
+    media: {
+      id: 3,
+      ipAddress: "149.154.175.100",
+      port: 443
+    }
+  },
+  4: {
+    main: {
+      id: 4,
+      ipAddress: "149.154.167.91",
+      port: 443
+    },
+    media: {
+      id: 4,
+      ipAddress: "149.154.167.255",
+      port: 443
+    }
+  },
+  5: {
+    main: {
+      id: 5,
+      ipAddress: "91.108.56.179",
+      port: 443
+    },
+    media: {
+      id: 5,
+      ipAddress: "149.154.171.255",
+      port: 443
+    }
+  }
+};
+const DC_MAPPING_TEST = {
+  1: {
+    main: {
+      id: 1,
+      ipAddress: "149.154.175.10",
+      port: 80
+    },
+    media: {
+      id: 1,
+      ipAddress: "149.154.175.10",
+      port: 80
+    }
+  },
+  2: {
+    main: {
+      id: 2,
+      ipAddress: "149.154.167.40",
+      port: 443
+    },
+    media: {
+      id: 2,
+      ipAddress: "149.154.167.40",
+      port: 443
+    }
+  },
+  3: {
+    main: {
+      id: 3,
+      ipAddress: "149.154.175.117",
+      port: 443
+    },
+    media: {
+      id: 3,
+      ipAddress: "149.154.175.117",
+      port: 443
+    }
+  }
+};
+function isTestDc(ip) {
+  return Object.values(DC_MAPPING_TEST).some((dc) => dc.main.ipAddress === ip || dc.media.ipAddress === ip);
+}
+function parseIpFromBytes(data) {
+  if (data.length === 4) {
+    return `${data[0]}.${data[1]}.${data[2]}.${data[3]}`;
+  }
+  if (data.length === 16) {
+    let res = "";
+    for (let i = 0; i < 16; i += 2) {
+      res += data[i].toString(16).padStart(2, "0");
+      res += data[i + 1].toString(16).padStart(2, "0");
+      if (i < 14) res += ":";
+    }
+    return res;
+  }
+  throw new MtArgumentError("Invalid IP address length");
+}
+function serializeIpv4ToBytes(ip, buf) {
+  const parts = ip.split(".");
+  if (parts.length !== 4) {
+    throw new MtArgumentError("Invalid IPv4 address");
+  }
+  buf[0] = Number(parts[0]);
+  buf[1] = Number(parts[1]);
+  buf[2] = Number(parts[2]);
+  buf[3] = Number(parts[3]);
+}
+function serializeIpv6ToBytes(ip, buf) {
+  const parts = ip.split(":");
+  if (parts.length !== 8) {
+    throw new MtArgumentError("Invalid IPv6 address");
+  }
+  for (let i = 0; i < 8; i++) {
+    const val = Number.parseInt(parts[i], 16);
+    buf[i * 2] = val >> 8;
+    buf[i * 2 + 1] = val & 255;
+  }
+}
+function parseTelethonSession(session) {
+  if (session[0] !== "1") {
+    throw new MtArgumentError(`Invalid session string (version = ${session[0]})`);
+  }
+  session = session.slice(1);
+  const data = getPlatform().base64Decode(session, true);
+  const dv = dataViewFromBuffer(data);
+  const dcId = dv.getUint8(0);
+  const ipSize = session.length === 352 ? 4 : 16;
+  let pos = 1 + ipSize;
+  const ipBytes = data.subarray(1, pos);
+  const port = dv.getUint16(pos);
+  pos += 2;
+  const authKey = data.subarray(pos, pos + 256);
+  const ip = parseIpFromBytes(ipBytes);
+  return {
+    dcId,
+    ipAddress: ip,
+    ipv6: ipSize === 16,
+    port,
+    authKey
+  };
+}
+function serializeTelethonSession(session) {
+  if (session.authKey.length !== 256) {
+    throw new MtArgumentError("authKey must be 256 bytes long");
+  }
+  const ipSize = session.ipv6 ? 16 : 4;
+  const u8 = new Uint8Array(259 + ipSize);
+  const dv = dataViewFromBuffer(u8);
+  dv.setUint8(0, session.dcId);
+  let pos;
+  if (session.ipv6) {
+    serializeIpv6ToBytes(session.ipAddress, u8.subarray(1, 17));
+    pos = 17;
+  } else {
+    serializeIpv4ToBytes(session.ipAddress, u8.subarray(1, 5));
+    pos = 5;
+  }
+  dv.setUint16(pos, session.port);
+  pos += 2;
+  u8.set(session.authKey, pos);
+  let b64 = getPlatform().base64Encode(u8, true);
+  while (b64.length % 4 !== 0) b64 += "=";
+  return `1${b64}`;
+}
+function convertFromTelethonSession(session) {
+  if (typeof session === "string") {
+    session = parseTelethonSession(session);
+  }
+  const dc = {
+    id: session.dcId,
+    ipAddress: session.ipAddress,
+    port: session.port,
+    ipv6: session.ipv6
+  };
+  return {
+    version: 3,
+    // we don't exactly have that information. try to deduce it from DC_MAPPING_TEST
+    // todo: we should maybe check this at connect?
+    testMode: isTestDc(session.ipAddress),
+    primaryDcs: {
+      main: dc,
+      media: dc
+    },
+    authKey: session.authKey
+  };
+}
+function convertToTelethonSession(session) {
+  if (typeof session === "string") {
+    session = readStringSession(session);
+  }
+  return serializeTelethonSession({
+    dcId: session.primaryDcs.main.id,
+    ipAddress: session.primaryDcs.main.ipAddress,
+    port: session.primaryDcs.main.port,
+    ipv6: session.primaryDcs.main.ipv6 ?? false,
+    authKey: session.authKey
+  });
+}
+function parseGramjsSession(session) {
+  if (session[0] !== "1") {
+    throw new MtArgumentError(`Invalid session string (version = ${session[0]})`);
+  }
+  session = session.slice(1);
+  const data = getPlatform().base64Decode(session);
+  const dv = dataViewFromBuffer(data);
+  const dcId = dv.getUint8(0);
+  const ipSize = dv.getUint16(1);
+  let pos = 3 + ipSize;
+  const ip = getPlatform().utf8Decode(data.subarray(3, pos));
+  const port = dv.getUint16(pos);
+  pos += 2;
+  const authKey = data.subarray(pos, pos + 256);
+  return {
+    dcId,
+    ipAddress: ip,
+    ipv6: ip.includes(":"),
+    // dumb check but gramjs does this
+    port,
+    authKey
+  };
+}
+function serializeGramjsSession(session) {
+  if (session.authKey.length !== 256) {
+    throw new MtArgumentError("authKey must be 256 bytes long");
+  }
+  const ipEncoded = getPlatform().utf8Encode(session.ipAddress);
+  const u8 = new Uint8Array(261 + ipEncoded.length);
+  const dv = dataViewFromBuffer(u8);
+  dv.setUint8(0, session.dcId);
+  dv.setUint16(1, ipEncoded.length);
+  u8.set(ipEncoded, 3);
+  let pos = 3 + ipEncoded.length;
+  dv.setUint16(pos, session.port);
+  pos += 2;
+  u8.set(session.authKey, pos);
+  return `1${getPlatform().base64Encode(u8)}`;
+}
+function convertFromGramjsSession(session) {
+  if (typeof session === "string") {
+    session = parseGramjsSession(session);
+  }
+  return convertFromTelethonSession(session);
+}
+function convertToGramjsSession(session) {
+  if (typeof session === "string") {
+    session = readStringSession(session);
+  }
+  return serializeGramjsSession({
+    dcId: session.primaryDcs.main.id,
+    ipAddress: session.primaryDcs.main.ipAddress,
+    port: session.primaryDcs.main.port,
+    ipv6: session.primaryDcs.main.ipv6 ?? false,
+    authKey: session.authKey
+  });
+}
+function telegramRleEncode(buf) {
+  const len = buf.length;
+  const ret = [];
+  let count = 0;
+  for (let i = 0; i < len; i++) {
+    const cur = buf[i];
+    if (cur === 0) {
+      count += 1;
+    } else {
+      if (count > 0) {
+        ret.push(0, count);
+        count = 0;
+      }
+      ret.push(cur);
+    }
+  }
+  if (count > 0) {
+    ret.push(0, count);
+  }
+  return new Uint8Array(ret);
+}
+function telegramRleDecode(buf) {
+  const len = buf.length;
+  const ret = [];
+  let prev = -1;
+  for (let i = 0; i < len; i++) {
+    const cur = buf[i];
+    if (prev === 0) {
+      for (let j = 0; j < cur; j++) {
+        ret.push(prev);
+      }
+      prev = -1;
+    } else {
+      if (prev !== -1) ret.push(prev);
+      prev = cur;
+    }
+  }
+  if (prev !== -1) ret.push(prev);
+  return new Uint8Array(ret);
+}
+function parseMtkrutoSession(session) {
+  const data = telegramRleDecode(getPlatform().base64Decode(session, true));
+  const reader = TlBinaryReader.manual(data);
+  let dcIdStr = reader.string();
+  const authKey = reader.bytes();
+  const isTest = dcIdStr.endsWith("-test");
+  if (isTest) {
+    dcIdStr = dcIdStr.slice(0, -5);
+  }
+  const dcId = Number(dcIdStr);
+  if (Number.isNaN(dcId)) {
+    throw new MtArgumentError(`Invalid DC ID: ${dcIdStr}`);
+  }
+  return {
+    dcId,
+    isTest,
+    authKey
+  };
+}
+function serializeMtkrutoSession(session) {
+  const dcIdStr = `${session.dcId}${session.isTest ? "-test" : ""}`;
+  const writer = TlBinaryWriter.manual(session.authKey.length + dcIdStr.length + 8);
+  writer.string(dcIdStr);
+  writer.bytes(session.authKey);
+  return getPlatform().base64Encode(telegramRleEncode(writer.result()), true);
+}
+function convertFromMtkrutoSession(session) {
+  if (typeof session === "string") {
+    session = parseMtkrutoSession(session);
+  }
+  return {
+    version: 3,
+    testMode: session.isTest,
+    primaryDcs: (session.isTest ? DC_MAPPING_TEST : DC_MAPPING_PROD)[session.dcId],
+    authKey: session.authKey
+  };
+}
+function convertToMtkrutoSession(session) {
+  if (typeof session === "string") {
+    session = readStringSession(session);
+  }
+  return serializeMtkrutoSession({
+    dcId: session.primaryDcs.main.id,
+    isTest: session.testMode,
+    authKey: session.authKey
+  });
+}
+const SESSION_STRING_SIZE$1 = 351;
+const SESSION_STRING_SIZE_64 = 356;
+function parsePyrogramSession(session) {
+  const data = getPlatform().base64Decode(session, true);
+  const dv = dataViewFromBuffer(data);
+  if (session.length === SESSION_STRING_SIZE$1 || session.length === SESSION_STRING_SIZE_64) {
+    const dcId2 = dv.getUint8(0);
+    const isTest2 = dv.getUint8(1) !== 0;
+    const authKey2 = data.subarray(2, 258);
+    let userId2;
+    if (data.length === SESSION_STRING_SIZE$1) {
+      userId2 = dv.getUint32(258);
+    } else {
+      const high = dv.getUint32(258);
+      const low = dv.getUint32(262);
+      userId2 = Long.fromBits(low, high).toNumber();
+    }
+    const isBot2 = dv.getUint8(data.length - 1) !== 0;
+    return {
+      dcId: dcId2,
+      isTest: isTest2,
+      authKey: authKey2,
+      userId: userId2,
+      isBot: isBot2
+    };
+  }
+  const dcId = dv.getUint8(0);
+  const apiId = dv.getUint32(1);
+  const isTest = dv.getUint8(5) !== 0;
+  const authKey = data.subarray(6, 262);
+  const userId = longFromBuffer(data.subarray(262, 270), true, false).toNumber();
+  const isBot = dv.getUint8(270) !== 0;
+  return {
+    dcId,
+    apiId,
+    isTest,
+    authKey,
+    userId,
+    isBot
+  };
+}
+const SESSION_STRING_SIZE_OLD = 267;
+const SESSION_STRING_SIZE = 271;
+function serializePyrogramSession(session) {
+  if (session.authKey.length !== 256) {
+    throw new MtArgumentError("authKey must be 256 bytes long");
+  }
+  const userIdLong = Long.fromNumber(session.userId, true);
+  let u8;
+  if (session.apiId === void 0) {
+    u8 = new Uint8Array(SESSION_STRING_SIZE_OLD);
+    const dv = dataViewFromBuffer(u8);
+    dv.setUint8(0, session.dcId);
+    dv.setUint8(1, session.isTest ? 1 : 0);
+    u8.set(session.authKey, 2);
+    dv.setUint32(258, userIdLong.high);
+    dv.setUint32(262, userIdLong.low);
+    dv.setUint8(266, session.isBot ? 1 : 0);
+  } else {
+    u8 = new Uint8Array(SESSION_STRING_SIZE);
+    const dv = dataViewFromBuffer(u8);
+    dv.setUint8(0, session.dcId);
+    dv.setUint32(1, session.apiId);
+    dv.setUint8(5, session.isTest ? 1 : 0);
+    u8.set(session.authKey, 6);
+    dv.setUint32(262, userIdLong.high);
+    dv.setUint32(266, userIdLong.low);
+    dv.setUint8(270, session.isBot ? 1 : 0);
+  }
+  return getPlatform().base64Encode(u8, true);
+}
+function convertFromPyrogramSession(session) {
+  if (typeof session === "string") {
+    session = parsePyrogramSession(session);
+  }
+  return {
+    version: 3,
+    testMode: session.isTest,
+    primaryDcs: (session.isTest ? DC_MAPPING_TEST : DC_MAPPING_PROD)[session.dcId],
+    authKey: session.authKey,
+    self: {
+      userId: session.userId,
+      isBot: session.isBot,
+      isPremium: false,
+      usernames: []
+    }
+  };
+}
+function convertToPyrogramSession(session, params) {
+  if (typeof session === "string") {
+    session = readStringSession(session);
+  }
+  return serializePyrogramSession({
+    apiId: params?.apiId,
+    isBot: session.self?.isBot ?? false,
+    isTest: session.testMode,
+    userId: session.self?.userId ?? 0,
+    dcId: session.primaryDcs.main.id,
+    authKey: session.authKey
+  });
+}
+export {
+  DC_MAPPING_PROD,
+  DC_MAPPING_TEST,
+  convertFromGramjsSession,
+  convertFromMtkrutoSession,
+  convertFromPyrogramSession,
+  convertFromTelethonSession,
+  convertToGramjsSession,
+  convertToMtkrutoSession,
+  convertToPyrogramSession,
+  convertToTelethonSession,
+  isTestDc,
+  parseGramjsSession,
+  parseMtkrutoSession,
+  parsePyrogramSession,
+  parseTelethonSession,
+  serializeGramjsSession,
+  serializeMtkrutoSession,
+  serializePyrogramSession,
+  serializeTelethonSession
+};

package/mtkruto/__fixtures__/session.d.ts

@@ -0,0 +1 @@
+export declare const MTKRUTO_SESSION = "BjItdGVzdAAB_gABAQABWEIKa07Ch-9zoA024mDOpsv20TW4YwuoRRROqSi41YQCbD3c4nKnz7BcFIu1mfn6f6Xm3OTVqoT0zib4p_AuZD9H-t8j5AagecRg-oSpQlmjoiUazKQSxnxWotGWf1mPNntAeOvDNa5t1NjXUxmqdB3e2AjYLF_E2jDESVgUuDBQUMBHIDc_xFBAlz6kVxCZ6iINJHbnyJ2F19tbEPFJvSM999RKaFj5lUUVs0qKNXEUmsFYUuIdPBzjWilY8Uvf9nYU_xXd9CUAAXS5_i4aaWlHoTIf3zn8ZEINhDIU1DMauh5vhSWt7F0fkxODjtou-7PdIunuDtqyQm4steuNJc8";

package/mtkruto/convert.test.d.ts

@@ -0,0 +1 @@
+export {};

package/mtkruto/parse.test.d.ts

@@ -0,0 +1 @@
+export {};

package/mtkruto/serialize.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,26 +1,30 @@
 {
-  "name": "@mtcute/convert",
-  "version": "0.16.0",
-  "description": "Cross-library session conversion utilities",
-  "author": "alina sireneva <alina@tei.su>",
-  "license": "MIT",
-  "type": "module",
-  "sideEffects": false,
-  "scripts": {},
-  "exports": {
-    ".": {
-      "import": "./esm/index.js",
-      "require": "./cjs/index.js"
+    "name": "@mtcute/convert",
+    "type": "module",
+    "version": "0.16.9",
+    "description": "Cross-library session conversion utilities",
+    "author": "alina sireneva <alina@tei.su>",
+    "license": "MIT",
+    "sideEffects": false,
+    "exports": {
+        ".": {
+            "import": {
+                "types": "./index.d.ts",
+                "default": "./index.js"
+            },
+            "require": {
+                "types": "./index.d.cts",
+                "default": "./index.cjs"
+            }
+        }
+    },
+    "scripts": {},
+    "dependencies": {
+        "@mtcute/core": "^0.16.9"
+    },
+    "homepage": "https://mtcute.dev",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/mtcute/mtcute"
     }
-  },
-  "dependencies": {
-    "@mtcute/core": "^0.16.0"
-  },
-  "main": "cjs/index.js",
-  "module": "esm/index.js",
-  "homepage": "https://mtcute.dev",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/mtcute/mtcute"
-  }
 }

package/pyrogram/__fixtures__/session.d.ts

@@ -0,0 +1 @@
+export declare const PYROGRAM_TEST_SESSION = "AgAyyvcBTk6KssqikKPxEhxfXJpkoFIgQ_o8VpCk_4g0tcHe0rVCXx34AaDKvaNOlbkJOZ4jA3AI8iDYkI2opuifbM_7S2u9MMdnrjfg5jpfkXfI9-wF8DK_UBGIe1zk_Ibn0IHLRz-lkb-QqZNhh8O8Ggb8cieamatEYwLrkjkZR7JG53q76F0ktUd22L6_bUlp9p_qgXqBg8vZdkIIs9T1OiShw2X6TNO0lYqfJVaczMVQcT9Zt0FiyrAMpovFuT7-96OFKWcQ9gzrs_SHfz9HrQgBwvNSdkVziXTtxLJXsaNz3smGeyh-CEuEgdF3enIECnzftlvvUClLN_ylcPir1bi4_wAAAAEqEi1JAA";

package/pyrogram/__fixtures__/session_old.d.ts

@@ -0,0 +1 @@
+export declare const PYROGRAM_TEST_SESSION_OLD = "AgEWdHMtuA1pC01YkNiHpL1bC0yBC3wzGZCwSRWKlA_a69RhePUN3M51NpnwSXrW3pZV9FS8WjAwUkA23uT_49t8c7Umw3ihhKD6-hTpZ5wXC2MuC0EsF0-Z6WshYhT3gmN6QhEt0jlXo5cW1BJ3MYmXtsTWNf_hJfd3_wF_ZFa58ntVV-3qd08wQRhiL_IxM7L5YazjPw0dg2z92CqRARku_oq5D29V6W6bo8T-SLzF_ujj5ZcAQL25mJtCcXfhhjp9atxcrqnKzEs05xyrehnlJZKoGmnX0mF2P_6wUHqZC9tcTBUV4AmFcbuy7m_4SYLnJ8MbftNs7aWHHNcB1R4fAAAAASoSLUkA";

package/pyrogram/convert.test.d.ts

@@ -0,0 +1 @@
+export {};

package/pyrogram/parse.test.d.ts

@@ -0,0 +1 @@
+export {};

package/pyrogram/serialize.test.d.ts

@@ -0,0 +1 @@
+export {};

package/telethon/__fixtures__/session.d.ts

@@ -0,0 +1 @@
+export declare const TELETHON_TEST_SESSION = "1ApWapygAUChJS1_xwUK01Is4cOvQa1JKTn1POabdMUCfLmXNYFUyvG3v9Z_qbFNFp3zYP--3aVpTYI2DpB2Ib46p_bwSC0j1QEjvdQxJj26cVj8NfslrCkYrdV3glOhdczSq08kp31eqBGXMPhA7wy7DOcSLLAoy-Jf3Q_V_Q3y2a8_64ArFJe8PFfSqkdO56VQutajNLscFUtTQXUQFLJ7ft6vIl__UOc9tpQZEiFW7jWmID79WkfYLHFjuChTVKGMLDa8YcZj6z5Sq-pXPE9VbAbJ5L1JRqXOey3QGtZgJeIEww_WWD5nMMUfhLIydD2i7eDmVoUE5EIZPpsevJmjiGLw4vJk=";

package/telethon/__fixtures__/session_v6.d.ts

@@ -0,0 +1 @@
+export declare const TELETHON_TEST_SESSION_V6 = "1ASABCyjyPfABAAAAAAAAAA4Bu4pveAFWSE51_trKsrRQeMvGXMl8fI6NsGaWqdrXXeqyaXne9qNthqnrBmH56kHfOhFUCPSoVzNNrGgnQr67AYQbkhpP_Yml2EDd8epdc6Gywh4q2NBgYyW6VBT8UKg89-FebYTO6n47I1cJMGsSZ1ddxEOpIpHXsSmPdGBSTz6uaHbLYo0jnxd59PQn4H4dKb8FxuOQsUVa3vY_o79HMVMQRVT1IksUKFg5gAe5ZJ0yx6W4pMviVbC-TYZC0HInmv2fFMv-S3rQyg1C7qpU-Gbo1P6UZC4KZGmu2pMJooFNyfRbFgl3BI5Z-FNx9TKu4UFrF9G6Q0l8PjPXOZm4j-c=";

package/telethon/convert.test.d.ts

@@ -0,0 +1 @@
+export {};

package/telethon/parse.test.d.ts

@@ -0,0 +1 @@
+export {};

package/telethon/serialize.test.d.ts

@@ -0,0 +1 @@
+export {};

package/cjs/dcs.js

@@ -1,113 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isTestDc = exports.DC_MAPPING_TEST = exports.DC_MAPPING_PROD = void 0;
-// some libraries only store the DCs in the source code, so we need to map them to the correct DCs
-// this may not be very accurate, but it's better than nothing
-// we *could* always map those to the primary dc (the client should handle that gracefully),
-// but imo it's better to be as accurate as possible
-// we'll also only map to ipv4 since that's more portable
-exports.DC_MAPPING_PROD = {
-    '1': {
-        main: {
-            id: 1,
-            ipAddress: '149.154.175.56',
-            port: 443,
-        },
-        media: {
-            id: 1,
-            ipAddress: '149.154.175.211',
-            port: 443,
-        },
-    },
-    '2': {
-        main: {
-            id: 2,
-            ipAddress: '149.154.167.41',
-            port: 443,
-        },
-        media: {
-            id: 2,
-            ipAddress: '149.154.167.35',
-            port: 443,
-        },
-    },
-    '3': {
-        main: {
-            id: 3,
-            ipAddress: '149.154.175.100',
-            port: 443,
-        },
-        media: {
-            id: 3,
-            ipAddress: '149.154.175.100',
-            port: 443,
-        },
-    },
-    '4': {
-        main: {
-            id: 4,
-            ipAddress: '149.154.167.91',
-            port: 443,
-        },
-        media: {
-            id: 4,
-            ipAddress: '149.154.167.255',
-            port: 443,
-        },
-    },
-    '5': {
-        main: {
-            id: 5,
-            ipAddress: '91.108.56.179',
-            port: 443,
-        },
-        media: {
-            id: 5,
-            ipAddress: '149.154.171.255',
-            port: 443,
-        },
-    },
-};
-exports.DC_MAPPING_TEST = {
-    '1': {
-        main: {
-            id: 1,
-            ipAddress: '149.154.175.10',
-            port: 80,
-        },
-        media: {
-            id: 1,
-            ipAddress: '149.154.175.10',
-            port: 80,
-        },
-    },
-    '2': {
-        main: {
-            id: 2,
-            ipAddress: '149.154.167.40',
-            port: 443,
-        },
-        media: {
-            id: 2,
-            ipAddress: '149.154.167.40',
-            port: 443,
-        },
-    },
-    '3': {
-        main: {
-            id: 3,
-            ipAddress: '149.154.175.117',
-            port: 443,
-        },
-        media: {
-            id: 3,
-            ipAddress: '149.154.175.117',
-            port: 443,
-        },
-    },
-};
-function isTestDc(ip) {
-    return Object.values(exports.DC_MAPPING_TEST).some((dc) => dc.main.ipAddress === ip || dc.media.ipAddress === ip);
-}
-exports.isTestDc = isTestDc;
-//# sourceMappingURL=dcs.js.map