cfpilot 0.40.2 → 0.40.9
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/assets/cfpilot-kernel-VERSION +5 -0
- package/assets/control.js +17 -17
- package/assets/dataplane.js +5 -5
- package/assets/worker.js +21 -21
- package/dist/cli.js +241 -5
- package/package.json +1 -1
package/dist/cli.js
CHANGED
|
@@ -87,7 +87,7 @@ var VERSION, NAME;
|
|
|
87
87
|
var init_version = __esm({
|
|
88
88
|
"src/shared/version.ts"() {
|
|
89
89
|
"use strict";
|
|
90
|
-
VERSION = "0.40.
|
|
90
|
+
VERSION = "0.40.9";
|
|
91
91
|
NAME = "cfpilot";
|
|
92
92
|
}
|
|
93
93
|
});
|
|
@@ -2088,10 +2088,92 @@ function extractBuildVersion(source) {
|
|
|
2088
2088
|
if (numeric?.[1]) return numeric[1];
|
|
2089
2089
|
return "";
|
|
2090
2090
|
}
|
|
2091
|
+
function channelAssetUrl(asset) {
|
|
2092
|
+
const base = process.env[KERNEL_CHANNEL_BASE_ENV]?.trim();
|
|
2093
|
+
if (base) return `${base.replace(/\/+$/, "")}/${asset}`;
|
|
2094
|
+
return `${RELEASES_WEB}/download/${KERNEL_CHANNEL_TAG}/${asset}`;
|
|
2095
|
+
}
|
|
2096
|
+
function parseKernelVersionManifest(text2) {
|
|
2097
|
+
try {
|
|
2098
|
+
const raw = JSON.parse(text2);
|
|
2099
|
+
const seq = Number(raw.seq);
|
|
2100
|
+
if (!Number.isFinite(seq) || !Number.isInteger(seq) || seq <= 0) return null;
|
|
2101
|
+
const build = typeof raw.build === "string" ? raw.build.trim() : "";
|
|
2102
|
+
const minToolVersion = typeof raw.minToolVersion === "string" ? raw.minToolVersion.trim() : "";
|
|
2103
|
+
return { seq, build, minToolVersion };
|
|
2104
|
+
} catch {
|
|
2105
|
+
return null;
|
|
2106
|
+
}
|
|
2107
|
+
}
|
|
2108
|
+
function isChannelNewer(channel, builtin) {
|
|
2109
|
+
if (channel.seq > builtin.seq) return true;
|
|
2110
|
+
return channel.seq === builtin.seq && channel.build !== "" && builtin.build !== "" && channel.build !== builtin.build;
|
|
2111
|
+
}
|
|
2112
|
+
async function fetchChannelVersion(timeoutMs) {
|
|
2113
|
+
try {
|
|
2114
|
+
const text2 = await downloadAsset(channelAssetUrl(KERNEL_VERSION_ASSET), timeoutMs);
|
|
2115
|
+
return parseKernelVersionManifest(text2);
|
|
2116
|
+
} catch {
|
|
2117
|
+
return null;
|
|
2118
|
+
}
|
|
2119
|
+
}
|
|
2120
|
+
async function loadBuiltinKernelVersion() {
|
|
2121
|
+
const override = process.env[LOCAL_DIR_ENV]?.trim();
|
|
2122
|
+
const candidates = override ? [resolve(override, KERNEL_VERSION_ASSET)] : [
|
|
2123
|
+
resolve(moduleDir(), `../assets/${KERNEL_VERSION_ASSET}`),
|
|
2124
|
+
resolve(moduleDir(), `../../assets/${KERNEL_VERSION_ASSET}`),
|
|
2125
|
+
resolve(moduleDir(), `../../worker-core/dist/${KERNEL_VERSION_ASSET}`),
|
|
2126
|
+
resolve(process.cwd(), `packages/worker-core/dist/${KERNEL_VERSION_ASSET}`)
|
|
2127
|
+
];
|
|
2128
|
+
for (const candidate of candidates) {
|
|
2129
|
+
try {
|
|
2130
|
+
const text2 = await readFile(candidate, "utf8");
|
|
2131
|
+
const parsed = parseKernelVersionManifest(text2);
|
|
2132
|
+
if (parsed) return parsed;
|
|
2133
|
+
} catch {
|
|
2134
|
+
}
|
|
2135
|
+
}
|
|
2136
|
+
return { seq: 0, build: "", minToolVersion: "" };
|
|
2137
|
+
}
|
|
2138
|
+
async function fetchChannelKernel(channel, timeoutMs) {
|
|
2139
|
+
const info = {
|
|
2140
|
+
version: `k${channel.seq}`,
|
|
2141
|
+
controlUrl: channelAssetUrl(CONTROL_ASSET_NAME),
|
|
2142
|
+
dataUrl: channelAssetUrl(DATA_ASSET_NAME),
|
|
2143
|
+
checksumsUrl: channelAssetUrl(CHECKSUMS_ASSET_NAME)
|
|
2144
|
+
};
|
|
2145
|
+
return await fetchRemoteKernel(info, timeoutMs);
|
|
2146
|
+
}
|
|
2091
2147
|
async function loadKernelBundle(currentVersion, options = {}) {
|
|
2092
2148
|
const log = options.log ?? (() => {
|
|
2093
2149
|
});
|
|
2094
2150
|
const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
|
|
2151
|
+
const channel = await fetchChannelVersion(timeoutMs);
|
|
2152
|
+
if (channel) {
|
|
2153
|
+
if (channel.minToolVersion && compareSemver(currentVersion, channel.minToolVersion) < 0) {
|
|
2154
|
+
log(
|
|
2155
|
+
`\xB7 \u8FDC\u7A0B\u5185\u6838 k${channel.seq} \u8981\u6C42\u5DE5\u5177\u7248\u672C \u2265 ${channel.minToolVersion}\uFF0C\u5F53\u524D ${currentVersion} \u2014\u2014 \u8BF7\u5148\u5347\u7EA7 CLI / \u684C\u9762\u7248\uFF0C\u518D\u66F4\u65B0\u5185\u6838`
|
|
2156
|
+
);
|
|
2157
|
+
} else {
|
|
2158
|
+
const builtin = await loadBuiltinKernelVersion();
|
|
2159
|
+
if (isChannelNewer(channel, builtin)) {
|
|
2160
|
+
try {
|
|
2161
|
+
const bundle = await fetchChannelKernel(channel, timeoutMs);
|
|
2162
|
+
return {
|
|
2163
|
+
control: bundle.control,
|
|
2164
|
+
data: bundle.data,
|
|
2165
|
+
version: currentVersion,
|
|
2166
|
+
source: `\u8FDC\u7A0B\u5185\u6838 k${channel.seq}\uFF08${channel.build || "build \u672A\u77E5"}\uFF0C\u5DF2\u6821\u9A8C\uFF09`
|
|
2167
|
+
};
|
|
2168
|
+
} catch (err) {
|
|
2169
|
+
log(
|
|
2170
|
+
`\xB7 \u8FDC\u7A0B\u5185\u6838 k${channel.seq} \u83B7\u53D6\u5931\u8D25\uFF0C\u6539\u7528\u5185\u7F6E\u5185\u6838 ${currentVersion}\uFF08\u90E8\u7F72\u7167\u5E38\u8FDB\u884C\uFF09\uFF1A` + (err instanceof Error ? err.message : String(err))
|
|
2171
|
+
);
|
|
2172
|
+
log(` \u2192 \u5F53\u524D\u8BBF\u95EE\u65B9\u5F0F\uFF1A${describeProxy()}`);
|
|
2173
|
+
}
|
|
2174
|
+
}
|
|
2175
|
+
}
|
|
2176
|
+
}
|
|
2095
2177
|
const remote = await fetchRemoteKernelInfo({ timeoutMs });
|
|
2096
2178
|
if (remote && compareSemver(remote.version, currentVersion) > 0) {
|
|
2097
2179
|
try {
|
|
@@ -2153,7 +2235,7 @@ async function fetchRemoteKernel(info, timeoutMs) {
|
|
|
2153
2235
|
await writeCached(dataPath, data).catch(() => void 0);
|
|
2154
2236
|
return { control, data };
|
|
2155
2237
|
}
|
|
2156
|
-
var CONTROL_ASSET_NAME, DATA_ASSET_NAME, CHECKSUMS_ASSET_NAME, REPO, RELEASES_API2, DEFAULT_TIMEOUT_MS, MAX_ASSET_BYTES, CACHE_DIR_ENV, LOCAL_DIR_ENV, REMOTE_OFF_ENV, BUILD_RE, BUILD_NUMERIC_RE, ASSET_BY_SHORT_NAME;
|
|
2238
|
+
var CONTROL_ASSET_NAME, DATA_ASSET_NAME, CHECKSUMS_ASSET_NAME, REPO, RELEASES_API2, DEFAULT_TIMEOUT_MS, MAX_ASSET_BYTES, CACHE_DIR_ENV, LOCAL_DIR_ENV, REMOTE_OFF_ENV, BUILD_RE, BUILD_NUMERIC_RE, ASSET_BY_SHORT_NAME, KERNEL_CHANNEL_TAG, KERNEL_VERSION_ASSET, KERNEL_CHANNEL_BASE_ENV;
|
|
2157
2239
|
var init_kernel_remote = __esm({
|
|
2158
2240
|
"src/deploy/kernel-remote.ts"() {
|
|
2159
2241
|
"use strict";
|
|
@@ -2176,6 +2258,9 @@ var init_kernel_remote = __esm({
|
|
|
2176
2258
|
"control.js": CONTROL_ASSET_NAME,
|
|
2177
2259
|
"dataplane.js": DATA_ASSET_NAME
|
|
2178
2260
|
};
|
|
2261
|
+
KERNEL_CHANNEL_TAG = "kernel-latest";
|
|
2262
|
+
KERNEL_VERSION_ASSET = "cfpilot-kernel-VERSION";
|
|
2263
|
+
KERNEL_CHANNEL_BASE_ENV = "CFPILOT_KERNEL_CHANNEL_BASE";
|
|
2179
2264
|
}
|
|
2180
2265
|
});
|
|
2181
2266
|
|
|
@@ -8009,6 +8094,9 @@ ${NAME} scan relay \u2014\u2014 \u53CD\u4EE3\u5165\u53E3\uFF08ProxyIP \u6C60\uFF
|
|
|
8009
8094
|
--top <n> \u4E0E --out / --push \u914D\u5408\uFF1A\u6700\u591A\u53D6\u51E0\u6761\uFF0C\u9ED8\u8BA4 10
|
|
8010
8095
|
--push <mode> \u76F4\u63A5\u5199\u5165\u9762\u677F ProxyIP \u6C60\uFF1Aincremental \u589E\u91CF / overwrite \u8986\u76D6
|
|
8011
8096
|
\u9700\u8981\u540C\u65F6\u7ED9 --panel \u4E0E --panel-password
|
|
8097
|
+
--verify-hosts <\u5217\u8868> \u6821\u9A8C\u7F51\u5740\uFF08\u9017\u53F7\u5206\u9694\uFF0CCloudflare \u7F51\u6BB5\u7AD9\u70B9\uFF09\uFF1A
|
|
8098
|
+
\u7EC8\u68C0\u5019\u9009\u80FD\u5426\u628A\u6D41\u91CF\u8F6C\u53D1\u5230 CF \u8FB9\u7F18\uFF0C\u8F6C\u53D1\u4E0D\u4E86\u7684\u5047\u5165\u53E3\u5254\u9664\uFF1B
|
|
8099
|
+
\u7559\u7A7A = \u5185\u7F6E\u6E05\u5355\uFF08cloudflare.com / chatgpt.com \u7B49\uFF0C\u4E0A\u9650 3 \u4E2A\uFF09
|
|
8012
8100
|
--panel <domain> \u63A7\u5236\u9762\u57DF\u540D\uFF08--push \u65F6\u5FC5\u586B\uFF09
|
|
8013
8101
|
--panel-password <pw> \u9762\u677F\u767B\u5F55\u5BC6\u7801\uFF08--push \u65F6\u5FC5\u586B\uFF09
|
|
8014
8102
|
--json \u8F93\u51FA\u673A\u5668\u53EF\u8BFB JSON
|
|
@@ -9053,6 +9141,91 @@ function percentile(values, p) {
|
|
|
9053
9141
|
const idx = Math.min(sorted.length - 1, Math.max(0, Math.ceil(p / 100 * sorted.length) - 1));
|
|
9054
9142
|
return sorted[idx];
|
|
9055
9143
|
}
|
|
9144
|
+
function isCloudflareIPv4(ip) {
|
|
9145
|
+
const parts = ip.split(".").map(Number);
|
|
9146
|
+
if (parts.length !== 4 || parts.some((n) => !Number.isInteger(n) || n < 0 || n > 255)) return false;
|
|
9147
|
+
const value = (parts[0] << 24 | parts[1] << 16 | parts[2] << 8 | parts[3]) >>> 0;
|
|
9148
|
+
return CF_RANGES.some(({ base, bits }) => {
|
|
9149
|
+
const mask = 4294967295 << 32 - bits >>> 0;
|
|
9150
|
+
const baseValue = (base[0] << 24 | base[1] << 16 | base[2] << 8 | base[3]) >>> 0 & mask;
|
|
9151
|
+
return (value & mask) === baseValue;
|
|
9152
|
+
});
|
|
9153
|
+
}
|
|
9154
|
+
async function resolveVerifyHosts(userRaw, quiet) {
|
|
9155
|
+
const verifyHostLimit = 3;
|
|
9156
|
+
const userHosts = userRaw.split(/[\r\n,]+/).map((s) => s.trim().toLowerCase()).filter(Boolean);
|
|
9157
|
+
const out2 = [];
|
|
9158
|
+
const seen = /* @__PURE__ */ new Set();
|
|
9159
|
+
const add = (host) => {
|
|
9160
|
+
if (!host || seen.has(host) || out2.length >= verifyHostLimit) return;
|
|
9161
|
+
seen.add(host);
|
|
9162
|
+
out2.push(host);
|
|
9163
|
+
};
|
|
9164
|
+
for (const host of userHosts) {
|
|
9165
|
+
if (BUILTIN_VERIFY_HOSTS.includes(host)) {
|
|
9166
|
+
add(host);
|
|
9167
|
+
continue;
|
|
9168
|
+
}
|
|
9169
|
+
try {
|
|
9170
|
+
const addrs = await resolve4Async(host);
|
|
9171
|
+
if (!addrs.some((ip) => isCloudflareIPv4(ip))) {
|
|
9172
|
+
if (!quiet) process.stderr.write(`\u5DF2\u5254\u9664\u6821\u9A8C\u7F51\u5740 ${host}\uFF08\u89E3\u6790\u7ED3\u679C\u4E0D\u5728 Cloudflare \u7F51\u6BB5\uFF09
|
|
9173
|
+
`);
|
|
9174
|
+
continue;
|
|
9175
|
+
}
|
|
9176
|
+
add(host);
|
|
9177
|
+
} catch {
|
|
9178
|
+
if (!quiet) process.stderr.write(`\u5DF2\u5254\u9664\u6821\u9A8C\u7F51\u5740 ${host}\uFF08\u89E3\u6790\u5931\u8D25\uFF09
|
|
9179
|
+
`);
|
|
9180
|
+
}
|
|
9181
|
+
}
|
|
9182
|
+
for (const h of BUILTIN_VERIFY_HOSTS) {
|
|
9183
|
+
if (out2.length >= verifyHostLimit) break;
|
|
9184
|
+
add(h);
|
|
9185
|
+
}
|
|
9186
|
+
return out2;
|
|
9187
|
+
}
|
|
9188
|
+
async function verifyOne(opts, ip, verifyHost, timeoutMs) {
|
|
9189
|
+
let ws;
|
|
9190
|
+
let socket;
|
|
9191
|
+
try {
|
|
9192
|
+
const tunnel = await openTunnel(opts.wsUrl, opts.uuid, ip, 443, timeoutMs);
|
|
9193
|
+
ws = tunnel.ws;
|
|
9194
|
+
socket = await new Promise((resolve4, reject) => {
|
|
9195
|
+
const s = tls4.connect(
|
|
9196
|
+
{
|
|
9197
|
+
socket: tunnel.duplex,
|
|
9198
|
+
servername: verifyHost,
|
|
9199
|
+
// 校验网址是公网站点:证书链 + 主机名照常校验
|
|
9200
|
+
rejectUnauthorized: true
|
|
9201
|
+
},
|
|
9202
|
+
() => resolve4(s)
|
|
9203
|
+
);
|
|
9204
|
+
s.once("error", reject);
|
|
9205
|
+
});
|
|
9206
|
+
socket.write(
|
|
9207
|
+
`GET / HTTP/1.1\r
|
|
9208
|
+
Host: ${verifyHost}\r
|
|
9209
|
+
User-Agent: cfpilot-relay-verify\r
|
|
9210
|
+
Connection: close\r
|
|
9211
|
+
\r
|
|
9212
|
+
`
|
|
9213
|
+
);
|
|
9214
|
+
const res = await readHttp(socket, timeoutMs);
|
|
9215
|
+
return res.status > 0;
|
|
9216
|
+
} catch {
|
|
9217
|
+
return false;
|
|
9218
|
+
} finally {
|
|
9219
|
+
try {
|
|
9220
|
+
socket?.destroy();
|
|
9221
|
+
} catch {
|
|
9222
|
+
}
|
|
9223
|
+
try {
|
|
9224
|
+
ws?.close();
|
|
9225
|
+
} catch {
|
|
9226
|
+
}
|
|
9227
|
+
}
|
|
9228
|
+
}
|
|
9056
9229
|
async function runRelayCommand(args) {
|
|
9057
9230
|
if (flagBool(args, "h") || flagBool(args, "help")) {
|
|
9058
9231
|
process.stdout.write(SCAN_RELAY_HELP);
|
|
@@ -9074,6 +9247,7 @@ async function runRelayCommand(args) {
|
|
|
9074
9247
|
const pushKind = pushRaw === "append" ? "incremental" : pushRaw === "replace" ? "overwrite" : pushRaw;
|
|
9075
9248
|
const panel = flagString(args, "panel");
|
|
9076
9249
|
const panelPassword = flagString(args, "panel-password");
|
|
9250
|
+
const verifyHostsRaw = flagString(args, "verify-hosts");
|
|
9077
9251
|
if (!host || !wsPath || !uuid) {
|
|
9078
9252
|
process.stderr.write("\u7F3A\u5C11\u53C2\u6570\uFF1A--host\u3001--ws-path\u3001--uuid \u90FD\u662F\u5FC5\u586B\n");
|
|
9079
9253
|
process.stderr.write("\u5019\u9009\u9ED8\u8BA4\u7528\u5185\u7F6E\u6E05\u5355\uFF1B\u4E5F\u53EF\u7528 --file / --url \u6307\u5B9A\n");
|
|
@@ -9182,7 +9356,38 @@ async function runRelayCommand(args) {
|
|
|
9182
9356
|
});
|
|
9183
9357
|
const alwaysOk = aggregates.filter((a) => a.successPct === 100).length;
|
|
9184
9358
|
const neverOk = aggregates.filter((a) => a.successPct === 0).length;
|
|
9185
|
-
const
|
|
9359
|
+
const verifyHosts = await resolveVerifyHosts(verifyHostsRaw, quiet);
|
|
9360
|
+
const verifyFailed = /* @__PURE__ */ new Set();
|
|
9361
|
+
if (verifyHosts.length > 0 && !quiet) {
|
|
9362
|
+
process.stderr.write(`\u6821\u9A8C\u7F51\u5740\u7EC8\u68C0\uFF1A${verifyHosts.join(", ")}
|
|
9363
|
+
`);
|
|
9364
|
+
}
|
|
9365
|
+
if (verifyHosts.length > 0) {
|
|
9366
|
+
const passList = aggregates.filter((a) => a.successPct === 100).map((a) => a.ip);
|
|
9367
|
+
let vNext = 0;
|
|
9368
|
+
const vWorker = async () => {
|
|
9369
|
+
for (; ; ) {
|
|
9370
|
+
const k = vNext;
|
|
9371
|
+
vNext += 1;
|
|
9372
|
+
if (k >= passList.length) return;
|
|
9373
|
+
const ip = passList[k];
|
|
9374
|
+
let passed = false;
|
|
9375
|
+
for (const host2 of verifyHosts) {
|
|
9376
|
+
if (await verifyOne({ wsUrl, uuid }, ip, host2, timeoutMs)) {
|
|
9377
|
+
passed = true;
|
|
9378
|
+
break;
|
|
9379
|
+
}
|
|
9380
|
+
}
|
|
9381
|
+
if (!passed) verifyFailed.add(ip);
|
|
9382
|
+
}
|
|
9383
|
+
};
|
|
9384
|
+
await Promise.all(Array.from({ length: Math.min(concurrency, passList.length) }, () => vWorker()));
|
|
9385
|
+
if (verifyFailed.size > 0 && !quiet) {
|
|
9386
|
+
process.stderr.write(`\u6821\u9A8C\u7F51\u5740\u7EC8\u68C0\u5254\u9664 ${verifyFailed.size} \u4E2A\u5047\u5165\u53E3
|
|
9387
|
+
`);
|
|
9388
|
+
}
|
|
9389
|
+
}
|
|
9390
|
+
const picked = aggregates.filter((a) => a.successPct === 100 && !verifyFailed.has(a.ip)).slice(0, topN).map((a) => a.ip);
|
|
9186
9391
|
if (outPath) {
|
|
9187
9392
|
writeFileSync3(outPath, picked.join("\n") + (picked.length > 0 ? "\n" : ""), "utf8");
|
|
9188
9393
|
if (!quiet) process.stderr.write(`\u5DF2\u5199\u51FA ${picked.length} \u6761\u5230 ${outPath}
|
|
@@ -9251,7 +9456,7 @@ async function runRelayCommand(args) {
|
|
|
9251
9456
|
String(a.tlsMs),
|
|
9252
9457
|
String(a.tlsP95),
|
|
9253
9458
|
String(a.httpMs),
|
|
9254
|
-
a.errors[0] ?? ""
|
|
9459
|
+
a.errors[0] ?? (verifyFailed.has(a.ip) ? "\u6821\u9A8C\u7F51\u5740\u5931\u8D25\uFF08\u5047\u5165\u53E3\uFF09" : "")
|
|
9255
9460
|
]);
|
|
9256
9461
|
const widths = head.map((h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length)));
|
|
9257
9462
|
const line = (cells) => cells.map((c2, i) => c2.padEnd(widths[i])).join(" ");
|
|
@@ -9265,7 +9470,7 @@ async function runRelayCommand(args) {
|
|
|
9265
9470
|
}
|
|
9266
9471
|
process.stdout.write("\n\u63D0\u793A\uFF1A\u628A\u901A\u8FC7\u7387\u9AD8\u7684\u524D\u51E0\u6761\u586B\u5165\u9762\u677F\u300C\u5165\u7AD9\u914D\u7F6E \u2192 ProxyIP \u6C60\u300D\uFF08\u6BCF\u884C\u4E00\u6761\uFF09\u3002\n");
|
|
9267
9472
|
}
|
|
9268
|
-
var CONCURRENCY, DEFAULT_TIMEOUT_MS2;
|
|
9473
|
+
var CONCURRENCY, DEFAULT_TIMEOUT_MS2, BUILTIN_VERIFY_HOSTS, CF_RANGES, resolve4Async;
|
|
9269
9474
|
var init_relay = __esm({
|
|
9270
9475
|
"src/scan/relay.ts"() {
|
|
9271
9476
|
"use strict";
|
|
@@ -9277,6 +9482,37 @@ var init_relay = __esm({
|
|
|
9277
9482
|
init_callback();
|
|
9278
9483
|
CONCURRENCY = 8;
|
|
9279
9484
|
DEFAULT_TIMEOUT_MS2 = 12e3;
|
|
9485
|
+
BUILTIN_VERIFY_HOSTS = [
|
|
9486
|
+
"cloudflare.com",
|
|
9487
|
+
"chatgpt.com",
|
|
9488
|
+
"canva.com",
|
|
9489
|
+
"discord.com",
|
|
9490
|
+
"x.com"
|
|
9491
|
+
];
|
|
9492
|
+
CF_RANGES = [
|
|
9493
|
+
{ base: [104, 16, 0, 0], bits: 13 },
|
|
9494
|
+
{ base: [104, 24, 0, 0], bits: 14 },
|
|
9495
|
+
{ base: [172, 64, 0, 0], bits: 13 },
|
|
9496
|
+
{ base: [162, 158, 0, 0], bits: 15 },
|
|
9497
|
+
{ base: [188, 114, 96, 0], bits: 20 },
|
|
9498
|
+
{ base: [198, 41, 128, 0], bits: 17 },
|
|
9499
|
+
{ base: [103, 21, 244, 0], bits: 22 },
|
|
9500
|
+
{ base: [103, 22, 200, 0], bits: 22 },
|
|
9501
|
+
{ base: [103, 31, 4, 0], bits: 22 },
|
|
9502
|
+
{ base: [141, 101, 64, 0], bits: 18 },
|
|
9503
|
+
{ base: [108, 162, 192, 0], bits: 18 },
|
|
9504
|
+
{ base: [190, 93, 240, 0], bits: 20 },
|
|
9505
|
+
{ base: [197, 234, 240, 0], bits: 22 },
|
|
9506
|
+
{ base: [131, 0, 72, 0], bits: 22 },
|
|
9507
|
+
{ base: [1, 0, 0, 0], bits: 24 },
|
|
9508
|
+
{ base: [1, 1, 1, 0], bits: 24 }
|
|
9509
|
+
];
|
|
9510
|
+
resolve4Async = async (host) => {
|
|
9511
|
+
const dns = await import("node:dns");
|
|
9512
|
+
return new Promise((resolve4, reject) => {
|
|
9513
|
+
dns.resolve4(host, (err, addrs) => err ? reject(err) : resolve4(addrs));
|
|
9514
|
+
});
|
|
9515
|
+
};
|
|
9280
9516
|
}
|
|
9281
9517
|
});
|
|
9282
9518
|
|