@coana-tech/cli 14.12.47 → 14.12.49

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.
@@ -20878,7 +20878,7 @@ var require_signal_exit = __commonJS({
20878
20878
  };
20879
20879
  };
20880
20880
  } else {
20881
- assert11 = __require("assert");
20881
+ assert8 = __require("assert");
20882
20882
  signals = require_signals();
20883
20883
  isWin = /^win/i.test(process2.platform);
20884
20884
  EE3 = __require("events");
@@ -20901,7 +20901,7 @@ var require_signal_exit = __commonJS({
20901
20901
  return function() {
20902
20902
  };
20903
20903
  }
20904
- assert11.equal(typeof cb, "function", "a callback must be provided for exit handler");
20904
+ assert8.equal(typeof cb, "function", "a callback must be provided for exit handler");
20905
20905
  if (loaded === false) {
20906
20906
  load2();
20907
20907
  }
@@ -21007,7 +21007,7 @@ var require_signal_exit = __commonJS({
21007
21007
  }
21008
21008
  };
21009
21009
  }
21010
- var assert11;
21010
+ var assert8;
21011
21011
  var signals;
21012
21012
  var isWin;
21013
21013
  var EE3;
@@ -34942,7 +34942,7 @@ var require_follow_redirects = __commonJS({
34942
34942
  var http2 = __require("http");
34943
34943
  var https2 = __require("https");
34944
34944
  var Writable = __require("stream").Writable;
34945
- var assert11 = __require("assert");
34945
+ var assert8 = __require("assert");
34946
34946
  var debug = require_debug();
34947
34947
  (function detectUnsupportedEnvironment() {
34948
34948
  var looksLikeNode = typeof process !== "undefined";
@@ -34954,7 +34954,7 @@ var require_follow_redirects = __commonJS({
34954
34954
  })();
34955
34955
  var useNativeURL = false;
34956
34956
  try {
34957
- assert11(new URL3(""));
34957
+ assert8(new URL3(""));
34958
34958
  } catch (error) {
34959
34959
  useNativeURL = error.code === "ERR_INVALID_URL";
34960
34960
  }
@@ -35313,7 +35313,7 @@ var require_follow_redirects = __commonJS({
35313
35313
  if (!isString2(options.host) && !isString2(options.hostname)) {
35314
35314
  options.hostname = "::1";
35315
35315
  }
35316
- assert11.equal(options.protocol, protocol, "protocol mismatch");
35316
+ assert8.equal(options.protocol, protocol, "protocol mismatch");
35317
35317
  debug("options", options);
35318
35318
  return new RedirectableRequest(options, callback);
35319
35319
  }
@@ -35409,7 +35409,7 @@ var require_follow_redirects = __commonJS({
35409
35409
  request.destroy(error);
35410
35410
  }
35411
35411
  function isSubdomain(subdomain, domain) {
35412
- assert11(isString2(subdomain) && isString2(domain));
35412
+ assert8(isString2(subdomain) && isString2(domain));
35413
35413
  var dot = subdomain.length - domain.length - 1;
35414
35414
  return dot > 0 && subdomain[dot] === "." && subdomain.endsWith(domain);
35415
35415
  }
@@ -36166,7 +36166,7 @@ var require_tunnel = __commonJS({
36166
36166
  var http2 = __require("http");
36167
36167
  var https2 = __require("https");
36168
36168
  var events = __require("events");
36169
- var assert11 = __require("assert");
36169
+ var assert8 = __require("assert");
36170
36170
  var util6 = __require("util");
36171
36171
  exports.httpOverHttp = httpOverHttp;
36172
36172
  exports.httpsOverHttp = httpsOverHttp;
@@ -36797,7 +36797,7 @@ var require_constants = __commonJS({
36797
36797
  var require_util2 = __commonJS({
36798
36798
  "../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/core/util.js"(exports, module) {
36799
36799
  "use strict";
36800
- var assert11 = __require("assert");
36800
+ var assert8 = __require("assert");
36801
36801
  var { kDestroyed, kBodyUsed } = require_symbols();
36802
36802
  var { IncomingMessage } = __require("http");
36803
36803
  var stream4 = __require("stream");
@@ -36879,7 +36879,7 @@ var require_util2 = __commonJS({
36879
36879
  function getHostname(host) {
36880
36880
  if (host[0] === "[") {
36881
36881
  const idx2 = host.indexOf("]");
36882
- assert11(idx2 !== -1);
36882
+ assert8(idx2 !== -1);
36883
36883
  return host.substring(1, idx2);
36884
36884
  }
36885
36885
  const idx = host.indexOf(":");
@@ -36890,7 +36890,7 @@ var require_util2 = __commonJS({
36890
36890
  if (!host) {
36891
36891
  return null;
36892
36892
  }
36893
- assert11.strictEqual(typeof host, "string");
36893
+ assert8.strictEqual(typeof host, "string");
36894
36894
  const servername = getHostname(host);
36895
36895
  if (net.isIP(servername)) {
36896
36896
  return "";
@@ -39493,7 +39493,7 @@ var require_util3 = __commonJS({
39493
39493
  var { getGlobalOrigin } = require_global();
39494
39494
  var { performance: performance2 } = __require("perf_hooks");
39495
39495
  var { isBlobLike, toUSVString, ReadableStreamFrom } = require_util2();
39496
- var assert11 = __require("assert");
39496
+ var assert8 = __require("assert");
39497
39497
  var { isUint8Array } = __require("util/types");
39498
39498
  var supportedHashes = [];
39499
39499
  var crypto5;
@@ -39683,7 +39683,7 @@ var require_util3 = __commonJS({
39683
39683
  }
39684
39684
  function determineRequestsReferrer(request) {
39685
39685
  const policy = request.referrerPolicy;
39686
- assert11(policy);
39686
+ assert8(policy);
39687
39687
  let referrerSource = null;
39688
39688
  if (request.referrer === "client") {
39689
39689
  const globalOrigin = getGlobalOrigin();
@@ -39741,7 +39741,7 @@ var require_util3 = __commonJS({
39741
39741
  }
39742
39742
  }
39743
39743
  function stripURLForReferrer(url2, originOnly) {
39744
- assert11(url2 instanceof URL);
39744
+ assert8(url2 instanceof URL);
39745
39745
  if (url2.protocol === "file:" || url2.protocol === "about:" || url2.protocol === "blank:") {
39746
39746
  return "no-referrer";
39747
39747
  }
@@ -39920,7 +39920,7 @@ var require_util3 = __commonJS({
39920
39920
  if (result === void 0) {
39921
39921
  throw new TypeError("Value is not JSON serializable");
39922
39922
  }
39923
- assert11(typeof result === "string");
39923
+ assert8(typeof result === "string");
39924
39924
  return result;
39925
39925
  }
39926
39926
  var esIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()));
@@ -40014,7 +40014,7 @@ var require_util3 = __commonJS({
40014
40014
  }
40015
40015
  function isomorphicEncode(input) {
40016
40016
  for (let i2 = 0; i2 < input.length; i2++) {
40017
- assert11(input.charCodeAt(i2) <= 255);
40017
+ assert8(input.charCodeAt(i2) <= 255);
40018
40018
  }
40019
40019
  return input;
40020
40020
  }
@@ -40034,7 +40034,7 @@ var require_util3 = __commonJS({
40034
40034
  }
40035
40035
  }
40036
40036
  function urlIsLocal(url2) {
40037
- assert11("protocol" in url2);
40037
+ assert8("protocol" in url2);
40038
40038
  const protocol = url2.protocol;
40039
40039
  return protocol === "about:" || protocol === "blob:" || protocol === "data:";
40040
40040
  }
@@ -40045,7 +40045,7 @@ var require_util3 = __commonJS({
40045
40045
  return url2.protocol === "https:";
40046
40046
  }
40047
40047
  function urlIsHttpHttpsScheme(url2) {
40048
- assert11("protocol" in url2);
40048
+ assert8("protocol" in url2);
40049
40049
  const protocol = url2.protocol;
40050
40050
  return protocol === "http:" || protocol === "https:";
40051
40051
  }
@@ -40487,7 +40487,7 @@ var require_webidl = __commonJS({
40487
40487
  // ../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/fetch/dataURL.js
40488
40488
  var require_dataURL = __commonJS({
40489
40489
  "../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/fetch/dataURL.js"(exports, module) {
40490
- var assert11 = __require("assert");
40490
+ var assert8 = __require("assert");
40491
40491
  var { atob: atob2 } = __require("buffer");
40492
40492
  var { isomorphicDecode } = require_util3();
40493
40493
  var encoder = new TextEncoder();
@@ -40495,7 +40495,7 @@ var require_dataURL = __commonJS({
40495
40495
  var HTTP_WHITESPACE_REGEX = /(\u000A|\u000D|\u0009|\u0020)/;
40496
40496
  var HTTP_QUOTED_STRING_TOKENS = /[\u0009|\u0020-\u007E|\u0080-\u00FF]/;
40497
40497
  function dataURLProcessor(dataURL) {
40498
- assert11(dataURL.protocol === "data:");
40498
+ assert8(dataURL.protocol === "data:");
40499
40499
  let input = URLSerializer(dataURL, true);
40500
40500
  input = input.slice(5);
40501
40501
  const position = { position: 0 };
@@ -40681,7 +40681,7 @@ var require_dataURL = __commonJS({
40681
40681
  function collectAnHTTPQuotedString(input, position, extractValue2) {
40682
40682
  const positionStart = position.position;
40683
40683
  let value = "";
40684
- assert11(input[position.position] === '"');
40684
+ assert8(input[position.position] === '"');
40685
40685
  position.position++;
40686
40686
  while (true) {
40687
40687
  value += collectASequenceOfCodePoints(
@@ -40702,7 +40702,7 @@ var require_dataURL = __commonJS({
40702
40702
  value += input[position.position];
40703
40703
  position.position++;
40704
40704
  } else {
40705
- assert11(quoteOrBackslash === '"');
40705
+ assert8(quoteOrBackslash === '"');
40706
40706
  break;
40707
40707
  }
40708
40708
  }
@@ -40712,7 +40712,7 @@ var require_dataURL = __commonJS({
40712
40712
  return input.slice(positionStart, position.position);
40713
40713
  }
40714
40714
  function serializeAMimeType(mimeType) {
40715
- assert11(mimeType !== "failure");
40715
+ assert8(mimeType !== "failure");
40716
40716
  const { parameters, essence } = mimeType;
40717
40717
  let serialization = essence;
40718
40718
  for (let [name2, value] of parameters.entries()) {
@@ -41131,7 +41131,7 @@ var require_body = __commonJS({
41131
41131
  var { DOMException: DOMException2, structuredClone } = require_constants2();
41132
41132
  var { Blob: Blob2, File: NativeFile } = __require("buffer");
41133
41133
  var { kBodyUsed } = require_symbols();
41134
- var assert11 = __require("assert");
41134
+ var assert8 = __require("assert");
41135
41135
  var { isErrored } = require_util2();
41136
41136
  var { isUint8Array, isArrayBuffer: isArrayBuffer2 } = __require("util/types");
41137
41137
  var { File: UndiciFile } = require_file2();
@@ -41169,7 +41169,7 @@ var require_body = __commonJS({
41169
41169
  type: void 0
41170
41170
  });
41171
41171
  }
41172
- assert11(isReadableStreamLike(stream4));
41172
+ assert8(isReadableStreamLike(stream4));
41173
41173
  let action = null;
41174
41174
  let source = null;
41175
41175
  let length = null;
@@ -41285,8 +41285,8 @@ Content-Type: ${value.type || "application/octet-stream"}\r
41285
41285
  ReadableStream2 = __require("stream/web").ReadableStream;
41286
41286
  }
41287
41287
  if (object instanceof ReadableStream2) {
41288
- assert11(!util6.isDisturbed(object), "The body has already been consumed.");
41289
- assert11(!object.locked, "The stream is locked.");
41288
+ assert8(!util6.isDisturbed(object), "The body has already been consumed.");
41289
+ assert8(!object.locked, "The stream is locked.");
41290
41290
  }
41291
41291
  return extractBody(object, keepalive);
41292
41292
  }
@@ -41497,7 +41497,7 @@ var require_request = __commonJS({
41497
41497
  InvalidArgumentError: InvalidArgumentError2,
41498
41498
  NotSupportedError
41499
41499
  } = require_errors3();
41500
- var assert11 = __require("assert");
41500
+ var assert8 = __require("assert");
41501
41501
  var { kHTTP2BuildRequest, kHTTP2CopyHeaders, kHTTP1BuildRequest } = require_symbols();
41502
41502
  var util6 = require_util2();
41503
41503
  var tokenRegExp = /^[\^_`a-zA-Z\-0-9!#$%&'*+.|~]+$/;
@@ -41678,8 +41678,8 @@ var require_request = __commonJS({
41678
41678
  }
41679
41679
  }
41680
41680
  onConnect(abort) {
41681
- assert11(!this.aborted);
41682
- assert11(!this.completed);
41681
+ assert8(!this.aborted);
41682
+ assert8(!this.completed);
41683
41683
  if (this.error) {
41684
41684
  abort(this.error);
41685
41685
  } else {
@@ -41688,8 +41688,8 @@ var require_request = __commonJS({
41688
41688
  }
41689
41689
  }
41690
41690
  onHeaders(statusCode, headers, resume, statusText) {
41691
- assert11(!this.aborted);
41692
- assert11(!this.completed);
41691
+ assert8(!this.aborted);
41692
+ assert8(!this.completed);
41693
41693
  if (channels.headers.hasSubscribers) {
41694
41694
  channels.headers.publish({ request: this, response: { statusCode, headers, statusText } });
41695
41695
  }
@@ -41700,8 +41700,8 @@ var require_request = __commonJS({
41700
41700
  }
41701
41701
  }
41702
41702
  onData(chunk2) {
41703
- assert11(!this.aborted);
41704
- assert11(!this.completed);
41703
+ assert8(!this.aborted);
41704
+ assert8(!this.completed);
41705
41705
  try {
41706
41706
  return this[kHandler].onData(chunk2);
41707
41707
  } catch (err) {
@@ -41710,13 +41710,13 @@ var require_request = __commonJS({
41710
41710
  }
41711
41711
  }
41712
41712
  onUpgrade(statusCode, headers, socket) {
41713
- assert11(!this.aborted);
41714
- assert11(!this.completed);
41713
+ assert8(!this.aborted);
41714
+ assert8(!this.completed);
41715
41715
  return this[kHandler].onUpgrade(statusCode, headers, socket);
41716
41716
  }
41717
41717
  onComplete(trailers) {
41718
41718
  this.onFinally();
41719
- assert11(!this.aborted);
41719
+ assert8(!this.aborted);
41720
41720
  this.completed = true;
41721
41721
  if (channels.trailers.hasSubscribers) {
41722
41722
  channels.trailers.publish({ request: this, trailers });
@@ -42047,7 +42047,7 @@ var require_connect = __commonJS({
42047
42047
  "../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/core/connect.js"(exports, module) {
42048
42048
  "use strict";
42049
42049
  var net = __require("net");
42050
- var assert11 = __require("assert");
42050
+ var assert8 = __require("assert");
42051
42051
  var util6 = require_util2();
42052
42052
  var { InvalidArgumentError: InvalidArgumentError2, ConnectTimeoutError } = require_errors3();
42053
42053
  var tls;
@@ -42117,7 +42117,7 @@ var require_connect = __commonJS({
42117
42117
  servername = servername || options.servername || util6.getServerName(host) || null;
42118
42118
  const sessionKey = servername || hostname;
42119
42119
  const session = sessionCache.get(sessionKey) || null;
42120
- assert11(sessionKey);
42120
+ assert8(sessionKey);
42121
42121
  socket = tls.connect({
42122
42122
  highWaterMark: 16384,
42123
42123
  // TLS in node can't have bigger HWM anyway...
@@ -42136,7 +42136,7 @@ var require_connect = __commonJS({
42136
42136
  sessionCache.set(sessionKey, session2);
42137
42137
  });
42138
42138
  } else {
42139
- assert11(!httpSocket, "httpSocket can only be sent on TLS update");
42139
+ assert8(!httpSocket, "httpSocket can only be sent on TLS update");
42140
42140
  socket = net.connect({
42141
42141
  highWaterMark: 64 * 1024,
42142
42142
  // Same as nodejs fs streams.
@@ -42545,7 +42545,7 @@ var require_RedirectHandler = __commonJS({
42545
42545
  "use strict";
42546
42546
  var util6 = require_util2();
42547
42547
  var { kBodyUsed } = require_symbols();
42548
- var assert11 = __require("assert");
42548
+ var assert8 = __require("assert");
42549
42549
  var { InvalidArgumentError: InvalidArgumentError2 } = require_errors3();
42550
42550
  var EE3 = __require("events");
42551
42551
  var redirectableStatusCodes = [300, 301, 302, 303, 307, 308];
@@ -42556,7 +42556,7 @@ var require_RedirectHandler = __commonJS({
42556
42556
  this[kBodyUsed] = false;
42557
42557
  }
42558
42558
  async *[Symbol.asyncIterator]() {
42559
- assert11(!this[kBodyUsed], "disturbed");
42559
+ assert8(!this[kBodyUsed], "disturbed");
42560
42560
  this[kBodyUsed] = true;
42561
42561
  yield* this[kBody];
42562
42562
  }
@@ -42577,7 +42577,7 @@ var require_RedirectHandler = __commonJS({
42577
42577
  if (util6.isStream(this.opts.body)) {
42578
42578
  if (util6.bodyLength(this.opts.body) === 0) {
42579
42579
  this.opts.body.on("data", function() {
42580
- assert11(false);
42580
+ assert8(false);
42581
42581
  });
42582
42582
  }
42583
42583
  if (typeof this.opts.body.readableDidRead !== "boolean") {
@@ -42681,7 +42681,7 @@ var require_RedirectHandler = __commonJS({
42681
42681
  }
42682
42682
  }
42683
42683
  } else {
42684
- assert11(headers == null, "headers must be an object or an array");
42684
+ assert8(headers == null, "headers must be an object or an array");
42685
42685
  }
42686
42686
  return ret;
42687
42687
  }
@@ -42729,7 +42729,7 @@ var require_llhttp_simd_wasm = __commonJS({
42729
42729
  var require_client = __commonJS({
42730
42730
  "../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/client.js"(exports, module) {
42731
42731
  "use strict";
42732
- var assert11 = __require("assert");
42732
+ var assert8 = __require("assert");
42733
42733
  var net = __require("net");
42734
42734
  var http2 = __require("http");
42735
42735
  var { pipeline: pipeline2 } = __require("stream");
@@ -43067,7 +43067,7 @@ var require_client = __commonJS({
43067
43067
  }
43068
43068
  };
43069
43069
  function onHttp2SessionError(err) {
43070
- assert11(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID");
43070
+ assert8(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID");
43071
43071
  this[kSocket][kError] = err;
43072
43072
  onError(this[kClient], err);
43073
43073
  }
@@ -43088,7 +43088,7 @@ var require_client = __commonJS({
43088
43088
  client[kSocket] = null;
43089
43089
  client[kHTTP2Session] = null;
43090
43090
  if (client.destroyed) {
43091
- assert11(this[kPending] === 0);
43091
+ assert8(this[kPending] === 0);
43092
43092
  const requests = client[kQueue].splice(client[kRunningIdx]);
43093
43093
  for (let i2 = 0; i2 < requests.length; i2++) {
43094
43094
  const request = requests[i2];
@@ -43100,7 +43100,7 @@ var require_client = __commonJS({
43100
43100
  errorRequest(client, request, err);
43101
43101
  }
43102
43102
  client[kPendingIdx] = client[kRunningIdx];
43103
- assert11(client[kRunning] === 0);
43103
+ assert8(client[kRunning] === 0);
43104
43104
  client.emit(
43105
43105
  "disconnect",
43106
43106
  client[kUrl],
@@ -43127,35 +43127,35 @@ var require_client = __commonJS({
43127
43127
  return 0;
43128
43128
  },
43129
43129
  wasm_on_status: (p, at, len) => {
43130
- assert11.strictEqual(currentParser.ptr, p);
43130
+ assert8.strictEqual(currentParser.ptr, p);
43131
43131
  const start = at - currentBufferPtr + currentBufferRef.byteOffset;
43132
43132
  return currentParser.onStatus(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
43133
43133
  },
43134
43134
  wasm_on_message_begin: (p) => {
43135
- assert11.strictEqual(currentParser.ptr, p);
43135
+ assert8.strictEqual(currentParser.ptr, p);
43136
43136
  return currentParser.onMessageBegin() || 0;
43137
43137
  },
43138
43138
  wasm_on_header_field: (p, at, len) => {
43139
- assert11.strictEqual(currentParser.ptr, p);
43139
+ assert8.strictEqual(currentParser.ptr, p);
43140
43140
  const start = at - currentBufferPtr + currentBufferRef.byteOffset;
43141
43141
  return currentParser.onHeaderField(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
43142
43142
  },
43143
43143
  wasm_on_header_value: (p, at, len) => {
43144
- assert11.strictEqual(currentParser.ptr, p);
43144
+ assert8.strictEqual(currentParser.ptr, p);
43145
43145
  const start = at - currentBufferPtr + currentBufferRef.byteOffset;
43146
43146
  return currentParser.onHeaderValue(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
43147
43147
  },
43148
43148
  wasm_on_headers_complete: (p, statusCode, upgrade, shouldKeepAlive) => {
43149
- assert11.strictEqual(currentParser.ptr, p);
43149
+ assert8.strictEqual(currentParser.ptr, p);
43150
43150
  return currentParser.onHeadersComplete(statusCode, Boolean(upgrade), Boolean(shouldKeepAlive)) || 0;
43151
43151
  },
43152
43152
  wasm_on_body: (p, at, len) => {
43153
- assert11.strictEqual(currentParser.ptr, p);
43153
+ assert8.strictEqual(currentParser.ptr, p);
43154
43154
  const start = at - currentBufferPtr + currentBufferRef.byteOffset;
43155
43155
  return currentParser.onBody(new FastBuffer(currentBufferRef.buffer, start, len)) || 0;
43156
43156
  },
43157
43157
  wasm_on_message_complete: (p) => {
43158
- assert11.strictEqual(currentParser.ptr, p);
43158
+ assert8.strictEqual(currentParser.ptr, p);
43159
43159
  return currentParser.onMessageComplete() || 0;
43160
43160
  }
43161
43161
  /* eslint-enable camelcase */
@@ -43174,7 +43174,7 @@ var require_client = __commonJS({
43174
43174
  var TIMEOUT_IDLE = 3;
43175
43175
  var Parser4 = class {
43176
43176
  constructor(client, socket, { exports: exports2 }) {
43177
- assert11(Number.isFinite(client[kMaxHeadersSize]) && client[kMaxHeadersSize] > 0);
43177
+ assert8(Number.isFinite(client[kMaxHeadersSize]) && client[kMaxHeadersSize] > 0);
43178
43178
  this.llhttp = exports2;
43179
43179
  this.ptr = this.llhttp.llhttp_alloc(constants4.TYPE.RESPONSE);
43180
43180
  this.client = client;
@@ -43220,10 +43220,10 @@ var require_client = __commonJS({
43220
43220
  if (this.socket.destroyed || !this.paused) {
43221
43221
  return;
43222
43222
  }
43223
- assert11(this.ptr != null);
43224
- assert11(currentParser == null);
43223
+ assert8(this.ptr != null);
43224
+ assert8(currentParser == null);
43225
43225
  this.llhttp.llhttp_resume(this.ptr);
43226
- assert11(this.timeoutType === TIMEOUT_BODY);
43226
+ assert8(this.timeoutType === TIMEOUT_BODY);
43227
43227
  if (this.timeout) {
43228
43228
  if (this.timeout.refresh) {
43229
43229
  this.timeout.refresh();
@@ -43243,9 +43243,9 @@ var require_client = __commonJS({
43243
43243
  }
43244
43244
  }
43245
43245
  execute(data2) {
43246
- assert11(this.ptr != null);
43247
- assert11(currentParser == null);
43248
- assert11(!this.paused);
43246
+ assert8(this.ptr != null);
43247
+ assert8(currentParser == null);
43248
+ assert8(!this.paused);
43249
43249
  const { socket, llhttp } = this;
43250
43250
  if (data2.length > currentBufferSize) {
43251
43251
  if (currentBufferPtr) {
@@ -43287,8 +43287,8 @@ var require_client = __commonJS({
43287
43287
  }
43288
43288
  }
43289
43289
  destroy() {
43290
- assert11(this.ptr != null);
43291
- assert11(currentParser == null);
43290
+ assert8(this.ptr != null);
43291
+ assert8(currentParser == null);
43292
43292
  this.llhttp.llhttp_free(this.ptr);
43293
43293
  this.ptr = null;
43294
43294
  timers.clearTimeout(this.timeout);
@@ -43345,17 +43345,17 @@ var require_client = __commonJS({
43345
43345
  }
43346
43346
  onUpgrade(head) {
43347
43347
  const { upgrade, client, socket, headers, statusCode } = this;
43348
- assert11(upgrade);
43348
+ assert8(upgrade);
43349
43349
  const request = client[kQueue][client[kRunningIdx]];
43350
- assert11(request);
43351
- assert11(!socket.destroyed);
43352
- assert11(socket === client[kSocket]);
43353
- assert11(!this.paused);
43354
- assert11(request.upgrade || request.method === "CONNECT");
43350
+ assert8(request);
43351
+ assert8(!socket.destroyed);
43352
+ assert8(socket === client[kSocket]);
43353
+ assert8(!this.paused);
43354
+ assert8(request.upgrade || request.method === "CONNECT");
43355
43355
  this.statusCode = null;
43356
43356
  this.statusText = "";
43357
43357
  this.shouldKeepAlive = null;
43358
- assert11(this.headers.length % 2 === 0);
43358
+ assert8(this.headers.length % 2 === 0);
43359
43359
  this.headers = [];
43360
43360
  this.headersSize = 0;
43361
43361
  socket.unshift(head);
@@ -43383,8 +43383,8 @@ var require_client = __commonJS({
43383
43383
  if (!request) {
43384
43384
  return -1;
43385
43385
  }
43386
- assert11(!this.upgrade);
43387
- assert11(this.statusCode < 200);
43386
+ assert8(!this.upgrade);
43387
+ assert8(this.statusCode < 200);
43388
43388
  if (statusCode === 100) {
43389
43389
  util6.destroy(socket, new SocketError("bad response", util6.getSocketInfo(socket)));
43390
43390
  return -1;
@@ -43393,7 +43393,7 @@ var require_client = __commonJS({
43393
43393
  util6.destroy(socket, new SocketError("bad upgrade", util6.getSocketInfo(socket)));
43394
43394
  return -1;
43395
43395
  }
43396
- assert11.strictEqual(this.timeoutType, TIMEOUT_HEADERS);
43396
+ assert8.strictEqual(this.timeoutType, TIMEOUT_HEADERS);
43397
43397
  this.statusCode = statusCode;
43398
43398
  this.shouldKeepAlive = shouldKeepAlive || // Override llhttp value which does not allow keepAlive for HEAD.
43399
43399
  request.method === "HEAD" && !socket[kReset] && this.connection.toLowerCase() === "keep-alive";
@@ -43406,16 +43406,16 @@ var require_client = __commonJS({
43406
43406
  }
43407
43407
  }
43408
43408
  if (request.method === "CONNECT") {
43409
- assert11(client[kRunning] === 1);
43409
+ assert8(client[kRunning] === 1);
43410
43410
  this.upgrade = true;
43411
43411
  return 2;
43412
43412
  }
43413
43413
  if (upgrade) {
43414
- assert11(client[kRunning] === 1);
43414
+ assert8(client[kRunning] === 1);
43415
43415
  this.upgrade = true;
43416
43416
  return 2;
43417
43417
  }
43418
- assert11(this.headers.length % 2 === 0);
43418
+ assert8(this.headers.length % 2 === 0);
43419
43419
  this.headers = [];
43420
43420
  this.headersSize = 0;
43421
43421
  if (this.shouldKeepAlive && client[kPipelining]) {
@@ -43458,14 +43458,14 @@ var require_client = __commonJS({
43458
43458
  return -1;
43459
43459
  }
43460
43460
  const request = client[kQueue][client[kRunningIdx]];
43461
- assert11(request);
43462
- assert11.strictEqual(this.timeoutType, TIMEOUT_BODY);
43461
+ assert8(request);
43462
+ assert8.strictEqual(this.timeoutType, TIMEOUT_BODY);
43463
43463
  if (this.timeout) {
43464
43464
  if (this.timeout.refresh) {
43465
43465
  this.timeout.refresh();
43466
43466
  }
43467
43467
  }
43468
- assert11(statusCode >= 200);
43468
+ assert8(statusCode >= 200);
43469
43469
  if (maxResponseSize > -1 && this.bytesRead + buf.length > maxResponseSize) {
43470
43470
  util6.destroy(socket, new ResponseExceededMaxSizeError());
43471
43471
  return -1;
@@ -43484,15 +43484,15 @@ var require_client = __commonJS({
43484
43484
  return;
43485
43485
  }
43486
43486
  const request = client[kQueue][client[kRunningIdx]];
43487
- assert11(request);
43488
- assert11(statusCode >= 100);
43487
+ assert8(request);
43488
+ assert8(statusCode >= 100);
43489
43489
  this.statusCode = null;
43490
43490
  this.statusText = "";
43491
43491
  this.bytesRead = 0;
43492
43492
  this.contentLength = "";
43493
43493
  this.keepAlive = "";
43494
43494
  this.connection = "";
43495
- assert11(this.headers.length % 2 === 0);
43495
+ assert8(this.headers.length % 2 === 0);
43496
43496
  this.headers = [];
43497
43497
  this.headersSize = 0;
43498
43498
  if (statusCode < 200) {
@@ -43505,7 +43505,7 @@ var require_client = __commonJS({
43505
43505
  request.onComplete(headers);
43506
43506
  client[kQueue][client[kRunningIdx]++] = null;
43507
43507
  if (socket[kWriting]) {
43508
- assert11.strictEqual(client[kRunning], 0);
43508
+ assert8.strictEqual(client[kRunning], 0);
43509
43509
  util6.destroy(socket, new InformationalError("reset"));
43510
43510
  return constants4.ERROR.PAUSED;
43511
43511
  } else if (!shouldKeepAlive) {
@@ -43525,7 +43525,7 @@ var require_client = __commonJS({
43525
43525
  const { socket, timeoutType, client } = parser;
43526
43526
  if (timeoutType === TIMEOUT_HEADERS) {
43527
43527
  if (!socket[kWriting] || socket.writableNeedDrain || client[kRunning] > 1) {
43528
- assert11(!parser.paused, "cannot be paused while waiting for headers");
43528
+ assert8(!parser.paused, "cannot be paused while waiting for headers");
43529
43529
  util6.destroy(socket, new HeadersTimeoutError());
43530
43530
  }
43531
43531
  } else if (timeoutType === TIMEOUT_BODY) {
@@ -43533,7 +43533,7 @@ var require_client = __commonJS({
43533
43533
  util6.destroy(socket, new BodyTimeoutError());
43534
43534
  }
43535
43535
  } else if (timeoutType === TIMEOUT_IDLE) {
43536
- assert11(client[kRunning] === 0 && client[kKeepAliveTimeoutValue]);
43536
+ assert8(client[kRunning] === 0 && client[kKeepAliveTimeoutValue]);
43537
43537
  util6.destroy(socket, new InformationalError("socket idle timeout"));
43538
43538
  }
43539
43539
  }
@@ -43545,7 +43545,7 @@ var require_client = __commonJS({
43545
43545
  }
43546
43546
  function onSocketError(err) {
43547
43547
  const { [kClient]: client, [kParser]: parser } = this;
43548
- assert11(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID");
43548
+ assert8(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID");
43549
43549
  if (client[kHTTPConnVersion] !== "h2") {
43550
43550
  if (err.code === "ECONNRESET" && parser.statusCode && !parser.shouldKeepAlive) {
43551
43551
  parser.onMessageComplete();
@@ -43557,13 +43557,13 @@ var require_client = __commonJS({
43557
43557
  }
43558
43558
  function onError(client, err) {
43559
43559
  if (client[kRunning] === 0 && err.code !== "UND_ERR_INFO" && err.code !== "UND_ERR_SOCKET") {
43560
- assert11(client[kPendingIdx] === client[kRunningIdx]);
43560
+ assert8(client[kPendingIdx] === client[kRunningIdx]);
43561
43561
  const requests = client[kQueue].splice(client[kRunningIdx]);
43562
43562
  for (let i2 = 0; i2 < requests.length; i2++) {
43563
43563
  const request = requests[i2];
43564
43564
  errorRequest(client, request, err);
43565
43565
  }
43566
- assert11(client[kSize] === 0);
43566
+ assert8(client[kSize] === 0);
43567
43567
  }
43568
43568
  }
43569
43569
  function onSocketEnd() {
@@ -43588,7 +43588,7 @@ var require_client = __commonJS({
43588
43588
  const err = this[kError] || new SocketError("closed", util6.getSocketInfo(this));
43589
43589
  client[kSocket] = null;
43590
43590
  if (client.destroyed) {
43591
- assert11(client[kPending] === 0);
43591
+ assert8(client[kPending] === 0);
43592
43592
  const requests = client[kQueue].splice(client[kRunningIdx]);
43593
43593
  for (let i2 = 0; i2 < requests.length; i2++) {
43594
43594
  const request = requests[i2];
@@ -43600,19 +43600,19 @@ var require_client = __commonJS({
43600
43600
  errorRequest(client, request, err);
43601
43601
  }
43602
43602
  client[kPendingIdx] = client[kRunningIdx];
43603
- assert11(client[kRunning] === 0);
43603
+ assert8(client[kRunning] === 0);
43604
43604
  client.emit("disconnect", client[kUrl], [client], err);
43605
43605
  resume(client);
43606
43606
  }
43607
43607
  async function connect(client) {
43608
- assert11(!client[kConnecting]);
43609
- assert11(!client[kSocket]);
43608
+ assert8(!client[kConnecting]);
43609
+ assert8(!client[kSocket]);
43610
43610
  let { host, hostname, protocol, port } = client[kUrl];
43611
43611
  if (hostname[0] === "[") {
43612
43612
  const idx = hostname.indexOf("]");
43613
- assert11(idx !== -1);
43613
+ assert8(idx !== -1);
43614
43614
  const ip = hostname.substring(1, idx);
43615
- assert11(net.isIP(ip));
43615
+ assert8(net.isIP(ip));
43616
43616
  hostname = ip;
43617
43617
  }
43618
43618
  client[kConnecting] = true;
@@ -43652,7 +43652,7 @@ var require_client = __commonJS({
43652
43652
  return;
43653
43653
  }
43654
43654
  client[kConnecting] = false;
43655
- assert11(socket);
43655
+ assert8(socket);
43656
43656
  const isH2 = socket.alpnProtocol === "h2";
43657
43657
  if (isH2) {
43658
43658
  if (!h2ExperimentalWarned) {
@@ -43728,7 +43728,7 @@ var require_client = __commonJS({
43728
43728
  });
43729
43729
  }
43730
43730
  if (err.code === "ERR_TLS_CERT_ALTNAME_INVALID") {
43731
- assert11(client[kRunning] === 0);
43731
+ assert8(client[kRunning] === 0);
43732
43732
  while (client[kPending] > 0 && client[kQueue][client[kPendingIdx]].servername === client[kServerName]) {
43733
43733
  const request = client[kQueue][client[kPendingIdx]++];
43734
43734
  errorRequest(client, request, err);
@@ -43760,7 +43760,7 @@ var require_client = __commonJS({
43760
43760
  function _resume(client, sync) {
43761
43761
  while (true) {
43762
43762
  if (client.destroyed) {
43763
- assert11(client[kPending] === 0);
43763
+ assert8(client[kPending] === 0);
43764
43764
  return;
43765
43765
  }
43766
43766
  if (client[kClosedResolve] && !client[kSize]) {
@@ -43932,13 +43932,13 @@ upgrade: ${upgrade}\r
43932
43932
  \r
43933
43933
  `, "latin1");
43934
43934
  } else {
43935
- assert11(contentLength === null, "no body must not have content length");
43935
+ assert8(contentLength === null, "no body must not have content length");
43936
43936
  socket.write(`${header}\r
43937
43937
  `, "latin1");
43938
43938
  }
43939
43939
  request.onRequestSent();
43940
43940
  } else if (util6.isBuffer(body)) {
43941
- assert11(contentLength === body.byteLength, "buffer body must have content length");
43941
+ assert8(contentLength === body.byteLength, "buffer body must have content length");
43942
43942
  socket.cork();
43943
43943
  socket.write(`${header}content-length: ${contentLength}\r
43944
43944
  \r
@@ -43961,7 +43961,7 @@ upgrade: ${upgrade}\r
43961
43961
  } else if (util6.isIterable(body)) {
43962
43962
  writeIterable({ body, client, request, socket, contentLength, header, expectsPayload });
43963
43963
  } else {
43964
- assert11(false);
43964
+ assert8(false);
43965
43965
  }
43966
43966
  return true;
43967
43967
  }
@@ -44030,7 +44030,7 @@ upgrade: ${upgrade}\r
44030
44030
  process.emitWarning(new RequestContentLengthMismatchError());
44031
44031
  }
44032
44032
  if (contentLength != null) {
44033
- assert11(body, "no body must not have content length");
44033
+ assert8(body, "no body must not have content length");
44034
44034
  headers[HTTP2_HEADER_CONTENT_LENGTH] = `${contentLength}`;
44035
44035
  }
44036
44036
  session.ref();
@@ -44086,7 +44086,7 @@ upgrade: ${upgrade}\r
44086
44086
  if (!body) {
44087
44087
  request.onRequestSent();
44088
44088
  } else if (util6.isBuffer(body)) {
44089
- assert11(contentLength === body.byteLength, "buffer body must have content length");
44089
+ assert8(contentLength === body.byteLength, "buffer body must have content length");
44090
44090
  stream4.cork();
44091
44091
  stream4.write(body);
44092
44092
  stream4.uncork();
@@ -44140,12 +44140,12 @@ upgrade: ${upgrade}\r
44140
44140
  socket: client[kSocket]
44141
44141
  });
44142
44142
  } else {
44143
- assert11(false);
44143
+ assert8(false);
44144
44144
  }
44145
44145
  }
44146
44146
  }
44147
44147
  function writeStream({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) {
44148
- assert11(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined");
44148
+ assert8(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined");
44149
44149
  if (client[kHTTPConnVersion] === "h2") {
44150
44150
  let onPipeData = function(chunk2) {
44151
44151
  request.onBodySent(chunk2);
@@ -44203,7 +44203,7 @@ upgrade: ${upgrade}\r
44203
44203
  return;
44204
44204
  }
44205
44205
  finished = true;
44206
- assert11(socket.destroyed || socket[kWriting] && client[kRunning] <= 1);
44206
+ assert8(socket.destroyed || socket[kWriting] && client[kRunning] <= 1);
44207
44207
  socket.off("drain", onDrain).off("error", onFinished);
44208
44208
  body.removeListener("data", onData).removeListener("end", onFinished).removeListener("error", onFinished).removeListener("close", onAbort);
44209
44209
  if (!err) {
@@ -44227,7 +44227,7 @@ upgrade: ${upgrade}\r
44227
44227
  socket.on("drain", onDrain).on("error", onFinished);
44228
44228
  }
44229
44229
  async function writeBlob({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) {
44230
- assert11(contentLength === body.size, "blob body must have content length");
44230
+ assert8(contentLength === body.size, "blob body must have content length");
44231
44231
  const isH2 = client[kHTTPConnVersion] === "h2";
44232
44232
  try {
44233
44233
  if (contentLength != null && contentLength !== body.size) {
@@ -44257,7 +44257,7 @@ upgrade: ${upgrade}\r
44257
44257
  }
44258
44258
  }
44259
44259
  async function writeIterable({ h2stream, body, client, request, socket, contentLength, header, expectsPayload }) {
44260
- assert11(contentLength !== 0 || client[kRunning] === 0, "iterator body cannot be pipelined");
44260
+ assert8(contentLength !== 0 || client[kRunning] === 0, "iterator body cannot be pipelined");
44261
44261
  let callback = null;
44262
44262
  function onDrain() {
44263
44263
  if (callback) {
@@ -44267,7 +44267,7 @@ upgrade: ${upgrade}\r
44267
44267
  }
44268
44268
  }
44269
44269
  const waitForDrain = () => new Promise((resolve20, reject) => {
44270
- assert11(callback === null);
44270
+ assert8(callback === null);
44271
44271
  if (socket[kError]) {
44272
44272
  reject(socket[kError]);
44273
44273
  } else {
@@ -44415,7 +44415,7 @@ ${len.toString(16)}\r
44415
44415
  const { socket, client } = this;
44416
44416
  socket[kWriting] = false;
44417
44417
  if (err) {
44418
- assert11(client[kRunning] <= 1, "pipeline should only contain this request");
44418
+ assert8(client[kRunning] <= 1, "pipeline should only contain this request");
44419
44419
  util6.destroy(socket, err);
44420
44420
  }
44421
44421
  }
@@ -44423,7 +44423,7 @@ ${len.toString(16)}\r
44423
44423
  function errorRequest(client, request, err) {
44424
44424
  try {
44425
44425
  request.onError(err);
44426
- assert11(request.aborted);
44426
+ assert8(request.aborted);
44427
44427
  } catch (err2) {
44428
44428
  client.emit("error", err2);
44429
44429
  }
@@ -45057,7 +45057,7 @@ var require_agent = __commonJS({
45057
45057
  var require_readable2 = __commonJS({
45058
45058
  "../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/api/readable.js"(exports, module) {
45059
45059
  "use strict";
45060
- var assert11 = __require("assert");
45060
+ var assert8 = __require("assert");
45061
45061
  var { Readable: Readable2 } = __require("stream");
45062
45062
  var { RequestAbortedError, NotSupportedError, InvalidArgumentError: InvalidArgumentError2 } = require_errors3();
45063
45063
  var util6 = require_util2();
@@ -45166,7 +45166,7 @@ var require_readable2 = __commonJS({
45166
45166
  this[kBody] = ReadableStreamFrom(this);
45167
45167
  if (this[kConsume]) {
45168
45168
  this[kBody].getReader();
45169
- assert11(this[kBody].locked);
45169
+ assert8(this[kBody].locked);
45170
45170
  }
45171
45171
  }
45172
45172
  return this[kBody];
@@ -45217,7 +45217,7 @@ var require_readable2 = __commonJS({
45217
45217
  if (isUnusable(stream4)) {
45218
45218
  throw new TypeError("unusable");
45219
45219
  }
45220
- assert11(!stream4[kConsume]);
45220
+ assert8(!stream4[kConsume]);
45221
45221
  return new Promise((resolve20, reject) => {
45222
45222
  stream4[kConsume] = {
45223
45223
  type,
@@ -45308,13 +45308,13 @@ var require_readable2 = __commonJS({
45308
45308
  // ../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/api/util.js
45309
45309
  var require_util4 = __commonJS({
45310
45310
  "../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/api/util.js"(exports, module) {
45311
- var assert11 = __require("assert");
45311
+ var assert8 = __require("assert");
45312
45312
  var {
45313
45313
  ResponseStatusCodeError
45314
45314
  } = require_errors3();
45315
45315
  var { toUSVString } = require_util2();
45316
45316
  async function getResolveErrorBodyCallback({ callback, body, contentType, statusCode, statusMessage, headers }) {
45317
- assert11(body);
45317
+ assert8(body);
45318
45318
  let chunks = [];
45319
45319
  let limit = 0;
45320
45320
  for await (const chunk2 of body) {
@@ -45742,7 +45742,7 @@ var require_api_pipeline = __commonJS({
45742
45742
  var util6 = require_util2();
45743
45743
  var { AsyncResource } = __require("async_hooks");
45744
45744
  var { addSignal, removeSignal } = require_abort_signal();
45745
- var assert11 = __require("assert");
45745
+ var assert8 = __require("assert");
45746
45746
  var kResume = Symbol("resume");
45747
45747
  var PipelineRequest = class extends Readable2 {
45748
45748
  constructor() {
@@ -45842,7 +45842,7 @@ var require_api_pipeline = __commonJS({
45842
45842
  }
45843
45843
  onConnect(abort, context) {
45844
45844
  const { ret, res } = this;
45845
- assert11(!res, "pipeline cannot be retried");
45845
+ assert8(!res, "pipeline cannot be retried");
45846
45846
  if (ret.destroyed) {
45847
45847
  throw new RequestAbortedError();
45848
45848
  }
@@ -45931,7 +45931,7 @@ var require_api_upgrade = __commonJS({
45931
45931
  var { AsyncResource } = __require("async_hooks");
45932
45932
  var util6 = require_util2();
45933
45933
  var { addSignal, removeSignal } = require_abort_signal();
45934
- var assert11 = __require("assert");
45934
+ var assert8 = __require("assert");
45935
45935
  var UpgradeHandler = class extends AsyncResource {
45936
45936
  constructor(opts, callback) {
45937
45937
  if (!opts || typeof opts !== "object") {
@@ -45964,7 +45964,7 @@ var require_api_upgrade = __commonJS({
45964
45964
  }
45965
45965
  onUpgrade(statusCode, rawHeaders, socket) {
45966
45966
  const { callback, opaque, context } = this;
45967
- assert11.strictEqual(statusCode, 101);
45967
+ assert8.strictEqual(statusCode, 101);
45968
45968
  removeSignal(this);
45969
45969
  this.callback = null;
45970
45970
  const headers = this.responseHeaders === "raw" ? util6.parseRawHeaders(rawHeaders) : util6.parseHeaders(rawHeaders);
@@ -47071,7 +47071,7 @@ var require_proxy_agent = __commonJS({
47071
47071
  // ../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/handler/RetryHandler.js
47072
47072
  var require_RetryHandler = __commonJS({
47073
47073
  "../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/handler/RetryHandler.js"(exports, module) {
47074
- var assert11 = __require("assert");
47074
+ var assert8 = __require("assert");
47075
47075
  var { kRetryHandlerDefaultRetry } = require_symbols();
47076
47076
  var { RequestRetryError } = require_errors3();
47077
47077
  var { isDisturbed, parseHeaders, parseRangeHeader } = require_util2();
@@ -47236,8 +47236,8 @@ var require_RetryHandler = __commonJS({
47236
47236
  return false;
47237
47237
  }
47238
47238
  const { start, size, end: end2 = size } = contentRange;
47239
- assert11(this.start === start, "content-range mismatch");
47240
- assert11(this.end == null || this.end === end2, "content-range mismatch");
47239
+ assert8(this.start === start, "content-range mismatch");
47240
+ assert8(this.end == null || this.end === end2, "content-range mismatch");
47241
47241
  this.resume = resume;
47242
47242
  return true;
47243
47243
  }
@@ -47253,12 +47253,12 @@ var require_RetryHandler = __commonJS({
47253
47253
  );
47254
47254
  }
47255
47255
  const { start, size, end: end2 = size } = range;
47256
- assert11(
47256
+ assert8(
47257
47257
  start != null && Number.isFinite(start) && this.start !== start,
47258
47258
  "content-range mismatch"
47259
47259
  );
47260
- assert11(Number.isFinite(start));
47261
- assert11(
47260
+ assert8(Number.isFinite(start));
47261
+ assert8(
47262
47262
  end2 != null && Number.isFinite(end2) && this.end !== end2,
47263
47263
  "invalid content-length"
47264
47264
  );
@@ -47269,8 +47269,8 @@ var require_RetryHandler = __commonJS({
47269
47269
  const contentLength = headers["content-length"];
47270
47270
  this.end = contentLength != null ? Number(contentLength) : null;
47271
47271
  }
47272
- assert11(Number.isFinite(this.start));
47273
- assert11(
47272
+ assert8(Number.isFinite(this.start));
47273
+ assert8(
47274
47274
  this.end == null || Number.isFinite(this.end),
47275
47275
  "invalid content-length"
47276
47276
  );
@@ -47412,7 +47412,7 @@ var require_headers = __commonJS({
47412
47412
  isValidHeaderValue
47413
47413
  } = require_util3();
47414
47414
  var { webidl } = require_webidl();
47415
- var assert11 = __require("assert");
47415
+ var assert8 = __require("assert");
47416
47416
  var kHeadersMap = Symbol("headers map");
47417
47417
  var kHeadersSortedMap = Symbol("headers map sorted");
47418
47418
  function isHTTPWhiteSpaceCharCode(code2) {
@@ -47670,7 +47670,7 @@ var require_headers = __commonJS({
47670
47670
  headers.push([name2, cookies[j]]);
47671
47671
  }
47672
47672
  } else {
47673
- assert11(value !== null);
47673
+ assert8(value !== null);
47674
47674
  headers.push([name2, value]);
47675
47675
  }
47676
47676
  }
@@ -47813,7 +47813,7 @@ var require_response = __commonJS({
47813
47813
  var { getGlobalOrigin } = require_global();
47814
47814
  var { URLSerializer } = require_dataURL();
47815
47815
  var { kHeadersList, kConstruct } = require_symbols();
47816
- var assert11 = __require("assert");
47816
+ var assert8 = __require("assert");
47817
47817
  var { types } = __require("util");
47818
47818
  var ReadableStream2 = globalThis.ReadableStream || __require("stream/web").ReadableStream;
47819
47819
  var textEncoder2 = new TextEncoder("utf-8");
@@ -48029,7 +48029,7 @@ var require_response = __commonJS({
48029
48029
  return p in state ? state[p] : target[p];
48030
48030
  },
48031
48031
  set(target, p, value) {
48032
- assert11(!(p in state));
48032
+ assert8(!(p in state));
48033
48033
  target[p] = value;
48034
48034
  return true;
48035
48035
  }
@@ -48063,11 +48063,11 @@ var require_response = __commonJS({
48063
48063
  body: null
48064
48064
  });
48065
48065
  } else {
48066
- assert11(false);
48066
+ assert8(false);
48067
48067
  }
48068
48068
  }
48069
48069
  function makeAppropriateNetworkError(fetchParams, err = null) {
48070
- assert11(isCancelled(fetchParams));
48070
+ assert8(isCancelled(fetchParams));
48071
48071
  return isAborted(fetchParams) ? makeNetworkError(Object.assign(new DOMException2("The operation was aborted.", "AbortError"), { cause: err })) : makeNetworkError(Object.assign(new DOMException2("Request was cancelled."), { cause: err }));
48072
48072
  }
48073
48073
  function initializeResponse(response, init, body) {
@@ -48195,7 +48195,7 @@ var require_request2 = __commonJS({
48195
48195
  var { getGlobalOrigin } = require_global();
48196
48196
  var { URLSerializer } = require_dataURL();
48197
48197
  var { kHeadersList, kConstruct } = require_symbols();
48198
- var assert11 = __require("assert");
48198
+ var assert8 = __require("assert");
48199
48199
  var { getMaxListeners, setMaxListeners, getEventListeners, defaultMaxListeners } = __require("events");
48200
48200
  var TransformStream = globalThis.TransformStream;
48201
48201
  var kAbortController = Symbol("abortController");
@@ -48239,7 +48239,7 @@ var require_request2 = __commonJS({
48239
48239
  request = makeRequest({ urlList: [parsedURL] });
48240
48240
  fallbackMode = "cors";
48241
48241
  } else {
48242
- assert11(input instanceof _Request);
48242
+ assert8(input instanceof _Request);
48243
48243
  request = input[kState];
48244
48244
  signal = input[kSignal];
48245
48245
  }
@@ -48848,7 +48848,7 @@ var require_fetch = __commonJS({
48848
48848
  urlHasHttpsScheme
48849
48849
  } = require_util3();
48850
48850
  var { kState, kHeaders, kGuard, kRealm } = require_symbols2();
48851
- var assert11 = __require("assert");
48851
+ var assert8 = __require("assert");
48852
48852
  var { safelyExtractBody } = require_body();
48853
48853
  var {
48854
48854
  redirectStatusSet,
@@ -48928,7 +48928,7 @@ var require_fetch = __commonJS({
48928
48928
  requestObject.signal,
48929
48929
  () => {
48930
48930
  locallyAborted = true;
48931
- assert11(controller != null);
48931
+ assert8(controller != null);
48932
48932
  controller.abort(requestObject.signal.reason);
48933
48933
  abortFetch(p, request, responseObject, requestObject.signal.reason);
48934
48934
  }
@@ -49061,7 +49061,7 @@ var require_fetch = __commonJS({
49061
49061
  taskDestination,
49062
49062
  crossOriginIsolatedCapability
49063
49063
  };
49064
- assert11(!request.body || request.body.stream);
49064
+ assert8(!request.body || request.body.stream);
49065
49065
  if (request.window === "client") {
49066
49066
  request.window = request.client?.globalObject?.constructor?.name === "Window" ? request.client : "no-window";
49067
49067
  }
@@ -49154,7 +49154,7 @@ var require_fetch = __commonJS({
49154
49154
  } else if (request.responseTainting === "opaque") {
49155
49155
  response = filterResponse(response, "opaque");
49156
49156
  } else {
49157
- assert11(false);
49157
+ assert8(false);
49158
49158
  }
49159
49159
  }
49160
49160
  let internalResponse = response.status === 0 ? response : response.internalResponse;
@@ -49346,7 +49346,7 @@ var require_fetch = __commonJS({
49346
49346
  } else if (request.redirect === "follow") {
49347
49347
  response = await httpRedirectFetch(fetchParams, response);
49348
49348
  } else {
49349
- assert11(false);
49349
+ assert8(false);
49350
49350
  }
49351
49351
  }
49352
49352
  response.timingInfo = timingInfo;
@@ -49399,7 +49399,7 @@ var require_fetch = __commonJS({
49399
49399
  request.headersList.delete("host");
49400
49400
  }
49401
49401
  if (request.body != null) {
49402
- assert11(request.body.source != null);
49402
+ assert8(request.body.source != null);
49403
49403
  request.body = safelyExtractBody(request.body.source)[0];
49404
49404
  }
49405
49405
  const timingInfo = fetchParams.timingInfo;
@@ -49532,7 +49532,7 @@ var require_fetch = __commonJS({
49532
49532
  return response;
49533
49533
  }
49534
49534
  async function httpNetworkFetch(fetchParams, includeCredentials = false, forceNewConnection = false) {
49535
- assert11(!fetchParams.controller.connection || fetchParams.controller.connection.destroyed);
49535
+ assert8(!fetchParams.controller.connection || fetchParams.controller.connection.destroyed);
49536
49536
  fetchParams.controller.connection = {
49537
49537
  abort: null,
49538
49538
  destroyed: false,
@@ -50667,7 +50667,7 @@ var require_symbols4 = __commonJS({
50667
50667
  var require_util6 = __commonJS({
50668
50668
  "../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/cache/util.js"(exports, module) {
50669
50669
  "use strict";
50670
- var assert11 = __require("assert");
50670
+ var assert8 = __require("assert");
50671
50671
  var { URLSerializer } = require_dataURL();
50672
50672
  var { isValidHeaderName: isValidHeaderName2 } = require_util3();
50673
50673
  function urlEquals(A, B2, excludeFragment = false) {
@@ -50676,7 +50676,7 @@ var require_util6 = __commonJS({
50676
50676
  return serializedA === serializedB;
50677
50677
  }
50678
50678
  function fieldValues(header) {
50679
- assert11(header !== null);
50679
+ assert8(header !== null);
50680
50680
  const values = [];
50681
50681
  for (let value of header.split(",")) {
50682
50682
  value = value.trim();
@@ -50710,7 +50710,7 @@ var require_cache = __commonJS({
50710
50710
  var { kState, kHeaders, kGuard, kRealm } = require_symbols2();
50711
50711
  var { fetching } = require_fetch();
50712
50712
  var { urlIsHttpHttpsScheme, createDeferredPromise, readAllBytes } = require_util3();
50713
- var assert11 = __require("assert");
50713
+ var assert8 = __require("assert");
50714
50714
  var { getGlobalDispatcher } = require_global2();
50715
50715
  var Cache = class _Cache {
50716
50716
  /**
@@ -50971,7 +50971,7 @@ var require_cache = __commonJS({
50971
50971
  return false;
50972
50972
  }
50973
50973
  } else {
50974
- assert11(typeof request === "string");
50974
+ assert8(typeof request === "string");
50975
50975
  r = new Request2(request)[kState];
50976
50976
  }
50977
50977
  const operations = [];
@@ -51080,7 +51080,7 @@ var require_cache = __commonJS({
51080
51080
  }
51081
51081
  for (const requestResponse of requestResponses) {
51082
51082
  const idx = cache.indexOf(requestResponse);
51083
- assert11(idx !== -1);
51083
+ assert8(idx !== -1);
51084
51084
  cache.splice(idx, 1);
51085
51085
  }
51086
51086
  } else if (operation.type === "put") {
@@ -51112,7 +51112,7 @@ var require_cache = __commonJS({
51112
51112
  requestResponses = this.#queryCache(operation.request);
51113
51113
  for (const requestResponse of requestResponses) {
51114
51114
  const idx = cache.indexOf(requestResponse);
51115
- assert11(idx !== -1);
51115
+ assert8(idx !== -1);
51116
51116
  cache.splice(idx, 1);
51117
51117
  }
51118
51118
  cache.push([operation.request, operation.response]);
@@ -51351,7 +51351,7 @@ var require_constants4 = __commonJS({
51351
51351
  var require_util7 = __commonJS({
51352
51352
  "../../node_modules/.pnpm/undici@5.28.5/node_modules/undici/lib/cookies/util.js"(exports, module) {
51353
51353
  "use strict";
51354
- var assert11 = __require("assert");
51354
+ var assert8 = __require("assert");
51355
51355
  var { kHeadersList } = require_symbols();
51356
51356
  function isCTLExcludingHtab(value) {
51357
51357
  if (value.length === 0) {
@@ -51492,10 +51492,10 @@ var require_util7 = __commonJS({
51492
51492
  kHeadersListNode = Object.getOwnPropertySymbols(headers).find(
51493
51493
  (symbol) => symbol.description === "headers list"
51494
51494
  );
51495
- assert11(kHeadersListNode, "Headers cannot be parsed");
51495
+ assert8(kHeadersListNode, "Headers cannot be parsed");
51496
51496
  }
51497
51497
  const headersList = headers[kHeadersListNode];
51498
- assert11(headersList);
51498
+ assert8(headersList);
51499
51499
  return headersList;
51500
51500
  }
51501
51501
  module.exports = {
@@ -51513,7 +51513,7 @@ var require_parse = __commonJS({
51513
51513
  var { maxNameValuePairSize, maxAttributeValueSize } = require_constants4();
51514
51514
  var { isCTLExcludingHtab } = require_util7();
51515
51515
  var { collectASequenceOfCodePointsFast } = require_dataURL();
51516
- var assert11 = __require("assert");
51516
+ var assert8 = __require("assert");
51517
51517
  function parseSetCookie(header) {
51518
51518
  if (isCTLExcludingHtab(header)) {
51519
51519
  return null;
@@ -51555,7 +51555,7 @@ var require_parse = __commonJS({
51555
51555
  if (unparsedAttributes.length === 0) {
51556
51556
  return cookieAttributeList;
51557
51557
  }
51558
- assert11(unparsedAttributes[0] === ";");
51558
+ assert8(unparsedAttributes[0] === ";");
51559
51559
  unparsedAttributes = unparsedAttributes.slice(1);
51560
51560
  let cookieAv = "";
51561
51561
  if (unparsedAttributes.includes(";")) {
@@ -54009,7 +54009,7 @@ var require_summary = __commonJS({
54009
54009
  exports.summary = exports.markdownSummary = exports.SUMMARY_DOCS_URL = exports.SUMMARY_ENV_VAR = void 0;
54010
54010
  var os_1 = __require("os");
54011
54011
  var fs_1 = __require("fs");
54012
- var { access: access3, appendFile, writeFile: writeFile10 } = fs_1.promises;
54012
+ var { access: access3, appendFile, writeFile: writeFile9 } = fs_1.promises;
54013
54013
  exports.SUMMARY_ENV_VAR = "GITHUB_STEP_SUMMARY";
54014
54014
  exports.SUMMARY_DOCS_URL = "https://docs.github.com/actions/using-workflows/workflow-commands-for-github-actions#adding-a-job-summary";
54015
54015
  var Summary = class {
@@ -54067,7 +54067,7 @@ var require_summary = __commonJS({
54067
54067
  return __awaiter(this, void 0, void 0, function* () {
54068
54068
  const overwrite = !!(options === null || options === void 0 ? void 0 : options.overwrite);
54069
54069
  const filePath = yield this.filePath();
54070
- const writeFunc = overwrite ? writeFile10 : appendFile;
54070
+ const writeFunc = overwrite ? writeFile9 : appendFile;
54071
54071
  yield writeFunc(filePath, this._buffer, { encoding: "utf8" });
54072
54072
  return this.emptyBuffer();
54073
54073
  });
@@ -55945,7 +55945,7 @@ var require_sync = __commonJS({
55945
55945
  var Glob = require_glob().Glob;
55946
55946
  var util6 = __require("util");
55947
55947
  var path9 = __require("path");
55948
- var assert11 = __require("assert");
55948
+ var assert8 = __require("assert");
55949
55949
  var isAbsolute2 = require_path_is_absolute();
55950
55950
  var common = require_common3();
55951
55951
  var setopts = common.setopts;
@@ -55975,7 +55975,7 @@ var require_sync = __commonJS({
55975
55975
  this._finish();
55976
55976
  }
55977
55977
  GlobSync.prototype._finish = function() {
55978
- assert11.ok(this instanceof GlobSync);
55978
+ assert8.ok(this instanceof GlobSync);
55979
55979
  if (this.realpath) {
55980
55980
  var self2 = this;
55981
55981
  this.matches.forEach(function(matchset, index2) {
@@ -55997,7 +55997,7 @@ var require_sync = __commonJS({
55997
55997
  common.finish(this);
55998
55998
  };
55999
55999
  GlobSync.prototype._process = function(pattern, index2, inGlobStar) {
56000
- assert11.ok(this instanceof GlobSync);
56000
+ assert8.ok(this instanceof GlobSync);
56001
56001
  var n = 0;
56002
56002
  while (typeof pattern[n] === "string") {
56003
56003
  n++;
@@ -56419,7 +56419,7 @@ var require_glob = __commonJS({
56419
56419
  var inherits2 = require_inherits();
56420
56420
  var EE3 = __require("events").EventEmitter;
56421
56421
  var path9 = __require("path");
56422
- var assert11 = __require("assert");
56422
+ var assert8 = __require("assert");
56423
56423
  var isAbsolute2 = require_path_is_absolute();
56424
56424
  var globSync = require_sync();
56425
56425
  var common = require_common3();
@@ -56522,7 +56522,7 @@ var require_glob = __commonJS({
56522
56522
  }
56523
56523
  }
56524
56524
  Glob.prototype._finish = function() {
56525
- assert11(this instanceof Glob);
56525
+ assert8(this instanceof Glob);
56526
56526
  if (this.aborted)
56527
56527
  return;
56528
56528
  if (this.realpath && !this._didRealpath)
@@ -56611,8 +56611,8 @@ var require_glob = __commonJS({
56611
56611
  }
56612
56612
  };
56613
56613
  Glob.prototype._process = function(pattern, index2, inGlobStar, cb) {
56614
- assert11(this instanceof Glob);
56615
- assert11(typeof cb === "function");
56614
+ assert8(this instanceof Glob);
56615
+ assert8(typeof cb === "function");
56616
56616
  if (this.aborted)
56617
56617
  return;
56618
56618
  this._processing++;
@@ -56968,7 +56968,7 @@ var require_glob = __commonJS({
56968
56968
  // ../../node_modules/.pnpm/rimraf@3.0.2/node_modules/rimraf/rimraf.js
56969
56969
  var require_rimraf = __commonJS({
56970
56970
  "../../node_modules/.pnpm/rimraf@3.0.2/node_modules/rimraf/rimraf.js"(exports, module) {
56971
- var assert11 = __require("assert");
56971
+ var assert8 = __require("assert");
56972
56972
  var path9 = __require("path");
56973
56973
  var fs12 = __require("fs");
56974
56974
  var glob = void 0;
@@ -57012,11 +57012,11 @@ var require_rimraf = __commonJS({
57012
57012
  cb = options;
57013
57013
  options = {};
57014
57014
  }
57015
- assert11(p, "rimraf: missing path");
57016
- assert11.equal(typeof p, "string", "rimraf: path should be a string");
57017
- assert11.equal(typeof cb, "function", "rimraf: callback function required");
57018
- assert11(options, "rimraf: invalid options argument provided");
57019
- assert11.equal(typeof options, "object", "rimraf: options should be object");
57015
+ assert8(p, "rimraf: missing path");
57016
+ assert8.equal(typeof p, "string", "rimraf: path should be a string");
57017
+ assert8.equal(typeof cb, "function", "rimraf: callback function required");
57018
+ assert8(options, "rimraf: invalid options argument provided");
57019
+ assert8.equal(typeof options, "object", "rimraf: options should be object");
57020
57020
  defaults2(options);
57021
57021
  let busyTries = 0;
57022
57022
  let errState = null;
@@ -57059,9 +57059,9 @@ var require_rimraf = __commonJS({
57059
57059
  });
57060
57060
  };
57061
57061
  var rimraf_ = (p, options, cb) => {
57062
- assert11(p);
57063
- assert11(options);
57064
- assert11(typeof cb === "function");
57062
+ assert8(p);
57063
+ assert8(options);
57064
+ assert8(typeof cb === "function");
57065
57065
  options.lstat(p, (er, st) => {
57066
57066
  if (er && er.code === "ENOENT")
57067
57067
  return cb(null);
@@ -57083,9 +57083,9 @@ var require_rimraf = __commonJS({
57083
57083
  });
57084
57084
  };
57085
57085
  var fixWinEPERM = (p, options, er, cb) => {
57086
- assert11(p);
57087
- assert11(options);
57088
- assert11(typeof cb === "function");
57086
+ assert8(p);
57087
+ assert8(options);
57088
+ assert8(typeof cb === "function");
57089
57089
  options.chmod(p, 438, (er2) => {
57090
57090
  if (er2)
57091
57091
  cb(er2.code === "ENOENT" ? null : er);
@@ -57101,8 +57101,8 @@ var require_rimraf = __commonJS({
57101
57101
  });
57102
57102
  };
57103
57103
  var fixWinEPERMSync = (p, options, er) => {
57104
- assert11(p);
57105
- assert11(options);
57104
+ assert8(p);
57105
+ assert8(options);
57106
57106
  try {
57107
57107
  options.chmodSync(p, 438);
57108
57108
  } catch (er2) {
@@ -57126,9 +57126,9 @@ var require_rimraf = __commonJS({
57126
57126
  options.unlinkSync(p);
57127
57127
  };
57128
57128
  var rmdir = (p, options, originalEr, cb) => {
57129
- assert11(p);
57130
- assert11(options);
57131
- assert11(typeof cb === "function");
57129
+ assert8(p);
57130
+ assert8(options);
57131
+ assert8(typeof cb === "function");
57132
57132
  options.rmdir(p, (er) => {
57133
57133
  if (er && (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM"))
57134
57134
  rmkids(p, options, cb);
@@ -57139,9 +57139,9 @@ var require_rimraf = __commonJS({
57139
57139
  });
57140
57140
  };
57141
57141
  var rmkids = (p, options, cb) => {
57142
- assert11(p);
57143
- assert11(options);
57144
- assert11(typeof cb === "function");
57142
+ assert8(p);
57143
+ assert8(options);
57144
+ assert8(typeof cb === "function");
57145
57145
  options.readdir(p, (er, files) => {
57146
57146
  if (er)
57147
57147
  return cb(er);
@@ -57164,10 +57164,10 @@ var require_rimraf = __commonJS({
57164
57164
  var rimrafSync = (p, options) => {
57165
57165
  options = options || {};
57166
57166
  defaults2(options);
57167
- assert11(p, "rimraf: missing path");
57168
- assert11.equal(typeof p, "string", "rimraf: path should be a string");
57169
- assert11(options, "rimraf: missing options");
57170
- assert11.equal(typeof options, "object", "rimraf: options should be object");
57167
+ assert8(p, "rimraf: missing path");
57168
+ assert8.equal(typeof p, "string", "rimraf: path should be a string");
57169
+ assert8(options, "rimraf: missing options");
57170
+ assert8.equal(typeof options, "object", "rimraf: options should be object");
57171
57171
  let results;
57172
57172
  if (options.disableGlob || !glob.hasMagic(p)) {
57173
57173
  results = [p];
@@ -57209,8 +57209,8 @@ var require_rimraf = __commonJS({
57209
57209
  }
57210
57210
  };
57211
57211
  var rmdirSync = (p, options, originalEr) => {
57212
- assert11(p);
57213
- assert11(options);
57212
+ assert8(p);
57213
+ assert8(options);
57214
57214
  try {
57215
57215
  options.rmdirSync(p);
57216
57216
  } catch (er) {
@@ -57223,8 +57223,8 @@ var require_rimraf = __commonJS({
57223
57223
  }
57224
57224
  };
57225
57225
  var rmkidsSync = (p, options) => {
57226
- assert11(p);
57227
- assert11(options);
57226
+ assert8(p);
57227
+ assert8(options);
57228
57228
  options.readdirSync(p).forEach((f2) => rimrafSync(path9.join(p, f2), options));
57229
57229
  const retries = isWindows4 ? 100 : 1;
57230
57230
  let i2 = 0;
@@ -69249,7 +69249,7 @@ var {
69249
69249
  } = import_index.default;
69250
69250
 
69251
69251
  // dist/reachability-analyzers-cli.js
69252
- import { readFile as readFile12, writeFile as writeFile9 } from "fs/promises";
69252
+ import { readFile as readFile12, writeFile as writeFile8 } from "fs/promises";
69253
69253
 
69254
69254
  // ../web-compat-utils/src/logger-singleton.ts
69255
69255
  var import_winston = __toESM(require_winston(), 1);
@@ -74256,7 +74256,7 @@ ${error.message}`);
74256
74256
  // dist/whole-program-code-aware-vulnerability-scanner/analyze-in-buckets.js
74257
74257
  var import_lodash17 = __toESM(require_lodash(), 1);
74258
74258
  var import_semver3 = __toESM(require_semver2(), 1);
74259
- import assert10 from "assert";
74259
+ import assert7 from "assert";
74260
74260
  import { relative as relative6 } from "path";
74261
74261
 
74262
74262
  // ../utils/src/promise-queue.ts
@@ -74424,7 +74424,7 @@ function getVulnReachability(c) {
74424
74424
 
74425
74425
  // dist/analyzers/pip-analyzer.js
74426
74426
  var import_lodash16 = __toESM(require_lodash(), 1);
74427
- import assert9 from "assert";
74427
+ import assert6 from "assert";
74428
74428
  import { resolve as resolve17 } from "path";
74429
74429
 
74430
74430
  // ../utils/src/pip-utils.ts
@@ -74696,9 +74696,9 @@ function addPathToTrie(root3, vulnPath) {
74696
74696
 
74697
74697
  // dist/whole-program-code-aware-vulnerability-scanner/python/python-code-aware-vulnerability-scanner.js
74698
74698
  var import_lodash14 = __toESM(require_lodash(), 1);
74699
- import assert8 from "assert";
74699
+ import assert5 from "assert";
74700
74700
  import { existsSync as existsSync11 } from "fs";
74701
- import { cp as cp5, readdir as readdir3, readFile as readFile10, rm as rm5, writeFile as writeFile8 } from "fs/promises";
74701
+ import { cp as cp5, readdir as readdir3, readFile as readFile10, rm as rm5 } from "fs/promises";
74702
74702
  import { basename as basename9, dirname as dirname12, join as join17, resolve as resolve15, sep as sep3 } from "path";
74703
74703
  import util5 from "util";
74704
74704
 
@@ -74877,7 +74877,6 @@ import { join as join10 } from "node:path";
74877
74877
  var classGraphAnalysisCliPath = join10(COANA_REPOS_PATH(), "class-graph-analysis", "dist", "bundle", "class-graph-analysis-cli.mjs");
74878
74878
 
74879
74879
  // dist/whole-program-code-aware-vulnerability-scanner/dotnet/dotnet-code-aware-vulnerability-scanner.js
74880
- import assert2 from "node:assert";
74881
74880
  var { uniq: uniq2, uniqWith, isEqual } = import_lodash6.default;
74882
74881
  var DotnetCodeAwareVulnerabilityScanner = class _DotnetCodeAwareVulnerabilityScanner {
74883
74882
  apps;
@@ -75143,10 +75142,9 @@ async function downloadAndExtractNugetPackage(packageName, version3, tmpDir) {
75143
75142
  }
75144
75143
  async function convertDependencyChain(dependencyChain, tmpDir) {
75145
75144
  const nugetDependencyChain = await asyncMap(dependencyChain, async (dep) => {
75146
- assert2(dep.version);
75147
75145
  return {
75148
75146
  ...dep,
75149
- bin: await downloadAndExtractNugetPackage(dep.packageName, dep.version, tmpDir)
75147
+ bin: dep.version ? await downloadAndExtractNugetPackage(dep.packageName, dep.version, tmpDir) : void 0
75150
75148
  };
75151
75149
  }, 4);
75152
75150
  return nugetDependencyChain;
@@ -75186,7 +75184,6 @@ async function convertSocketArtifacts(artifacts, tmpDir) {
75186
75184
  const deps = {};
75187
75185
  const depIdToPackageMap = {};
75188
75186
  await asyncForEach(artifacts, async (artifact) => {
75189
- assert2(artifact.version);
75190
75187
  const uuid = randomUUID();
75191
75188
  depIdToPackageMap[uuid] = {
75192
75189
  name: artifact.name,
@@ -75196,7 +75193,7 @@ async function convertSocketArtifacts(artifacts, tmpDir) {
75196
75193
  ecosystemSpecificPackageInfo: {
75197
75194
  type: "DOTNET"
75198
75195
  },
75199
- bin: await resolveNuGetPackage(artifact.name, artifact.version)
75196
+ bin: artifact.version ? await resolveNuGetPackage(artifact.name, artifact.version) : void 0
75200
75197
  };
75201
75198
  }, 4);
75202
75199
  return { deps, depIdToPackageMap };
@@ -88848,7 +88845,6 @@ var treeSitterScalaPath = join12(COANA_REPOS_PATH(), "tree-sitter-scala");
88848
88845
 
88849
88846
  // dist/whole-program-code-aware-vulnerability-scanner/java/java-code-aware-vulnerability-scanner.js
88850
88847
  var import_picomatch2 = __toESM(require_picomatch4(), 1);
88851
- import assert3 from "node:assert";
88852
88848
  var { uniq: uniq3, uniqWith: uniqWith2, isEqual: isEqual2 } = import_lodash8.default;
88853
88849
  var JavaCodeAwareVulnerabilityScanner = class _JavaCodeAwareVulnerabilityScanner {
88854
88850
  apps;
@@ -89113,10 +89109,9 @@ async function convertDependencyChain2(dependencyChain, tmpDir) {
89113
89109
  }
89114
89110
  const mavenDependencyChain = await asyncMap(dependencyChain, async (dep) => {
89115
89111
  const [groupId, artifactId] = dep.packageName.split(":");
89116
- assert3(dep.version);
89117
89112
  return {
89118
89113
  ...dep,
89119
- bin: await downloadMavenArtifacts(groupId, artifactId, dep.version)
89114
+ bin: dep.version ? await downloadMavenArtifacts(groupId, artifactId, dep.version) : void 0
89120
89115
  };
89121
89116
  });
89122
89117
  return mavenDependencyChain;
@@ -89175,17 +89170,15 @@ async function convertSocketArtifacts2(rootDir, artifacts, tmpDir) {
89175
89170
  const deps = {};
89176
89171
  const depIdToPackageMap = {};
89177
89172
  await asyncForEach(artifacts, async (artifact) => {
89178
- assert3(artifact.namespace);
89179
- assert3(artifact.version);
89180
89173
  const manifestFilesForArtifact = i([
89181
89174
  ...artifact.manifestFiles?.map((ref) => ref.file) ?? [],
89182
89175
  ...artifact.toplevelAncestors?.flatMap((ancestorId) => artifacts.find((a2) => a2.id === ancestorId)?.manifestFiles?.map((m) => m.file) ?? []) ?? []
89183
89176
  ]);
89184
89177
  const pomFile = manifestFilesForArtifact.find((manifestFile) => pomMatcher(basename5(manifestFile)));
89185
- const artifactFile = await resolveArtifact(artifact.namespace, artifact.name, artifact.qualifiers?.type, artifact.qualifiers?.classifier, artifact.version, pomFile);
89178
+ const artifactFile = artifact.namespace && artifact.version ? await resolveArtifact(artifact.namespace, artifact.name, artifact.qualifiers?.type, artifact.qualifiers?.classifier, artifact.version, pomFile) : void 0;
89186
89179
  const uuid = randomUUID2();
89187
89180
  depIdToPackageMap[uuid] = {
89188
- groupId: artifact.namespace,
89181
+ groupId: artifact.namespace ?? "",
89189
89182
  artifactId: artifact.name,
89190
89183
  type: artifact.qualifiers?.type,
89191
89184
  classifier: artifact.qualifiers?.classifier,
@@ -90585,7 +90578,7 @@ var makeCommand = (syncFile, asyncFile, syncNoFile, asyncNoFile, validate2) => {
90585
90578
  import { EventEmitter as EE2 } from "events";
90586
90579
 
90587
90580
  // ../../node_modules/.pnpm/minizlib@3.0.2/node_modules/minizlib/dist/esm/index.js
90588
- import assert4 from "assert";
90581
+ import assert2 from "assert";
90589
90582
  import { Buffer as Buffer2 } from "buffer";
90590
90583
  import * as realZlib2 from "zlib";
90591
90584
 
@@ -90777,7 +90770,7 @@ var ZlibBase = class extends Minipass {
90777
90770
  }
90778
90771
  reset() {
90779
90772
  if (!this.#sawError) {
90780
- assert4(this.#handle, "zlib binding closed");
90773
+ assert2(this.#handle, "zlib binding closed");
90781
90774
  return this.#handle.reset?.();
90782
90775
  }
90783
90776
  }
@@ -90822,7 +90815,7 @@ var ZlibBase = class extends Minipass {
90822
90815
  chunk2 = Buffer2.from(chunk2, encoding);
90823
90816
  if (this.#sawError)
90824
90817
  return;
90825
- assert4(this.#handle, "zlib binding closed");
90818
+ assert2(this.#handle, "zlib binding closed");
90826
90819
  const nativeHandle = this.#handle._handle;
90827
90820
  const originalNativeClose = nativeHandle.close;
90828
90821
  nativeHandle.close = () => {
@@ -90888,7 +90881,7 @@ var Zlib = class extends ZlibBase {
90888
90881
  throw new Error("not supported in this implementation");
90889
90882
  if (this.#level !== level || this.#strategy !== strategy) {
90890
90883
  this.flush(constants3.Z_SYNC_FLUSH);
90891
- assert4(this.handle, "zlib binding closed");
90884
+ assert2(this.handle, "zlib binding closed");
90892
90885
  const origFlush = this.handle.flush;
90893
90886
  this.handle.flush = (flushFlag, cb) => {
90894
90887
  if (typeof flushFlag === "function") {
@@ -93588,7 +93581,7 @@ var create2 = makeCommand(createFileSync, createFile, createSync, createAsync, (
93588
93581
  import fs9 from "node:fs";
93589
93582
 
93590
93583
  // ../../node_modules/.pnpm/tar@7.4.3/node_modules/tar/dist/esm/unpack.js
93591
- import assert5 from "node:assert";
93584
+ import assert3 from "node:assert";
93592
93585
  import { randomBytes } from "node:crypto";
93593
93586
  import fs8 from "node:fs";
93594
93587
  import path6 from "node:path";
@@ -94483,7 +94476,7 @@ var Unpack = class extends Parser3 {
94483
94476
  if (!this[CHECKPATH](entry)) {
94484
94477
  return entry.resume();
94485
94478
  }
94486
- assert5.equal(typeof entry.absolute, "string");
94479
+ assert3.equal(typeof entry.absolute, "string");
94487
94480
  switch (entry.type) {
94488
94481
  case "Directory":
94489
94482
  case "GNUDumpDir":
@@ -95715,7 +95708,7 @@ function transformSourceLocations(fileMappings, detectedOccurrences) {
95715
95708
 
95716
95709
  // dist/whole-program-code-aware-vulnerability-scanner/go/go-code-aware-vulnerability-scanner.js
95717
95710
  var import_lodash11 = __toESM(require_lodash(), 1);
95718
- import assert6 from "assert";
95711
+ import assert4 from "assert";
95719
95712
  import { existsSync as existsSync9, createReadStream, createWriteStream as createWriteStream2 } from "fs";
95720
95713
  import { readFile as readFile8, rm as rm4, cp as cp4 } from "fs/promises";
95721
95714
  import zlib2 from "zlib";
@@ -95818,7 +95811,7 @@ ${stderr}`);
95818
95811
  }
95819
95812
  }
95820
95813
  static async runOnDependencyChain([first2, ...rest], vuln, options = {}) {
95821
- assert6(first2.version);
95814
+ assert4(first2.version);
95822
95815
  const { Dir, GoMod } = JSON.parse(await runCommandResolveStdOut(cmdt`go mod download -json ${first2.packageName}@v${first2.version}`));
95823
95816
  const projectDir = await createTmpDirectory("go-run-on-dependency-chain-");
95824
95817
  try {
@@ -95852,7 +95845,7 @@ ${stderr}`);
95852
95845
  }
95853
95846
  static async runOnAlreadyDownloadedPackages(packages, vuln, options = {}) {
95854
95847
  for (const pkg of packages)
95855
- assert6(existsSync9(join15(pkg, "go.mod")), `${pkg} does not contain a go.mod file`);
95848
+ assert4(existsSync9(join15(pkg, "go.mod")), `${pkg} does not contain a go.mod file`);
95856
95849
  const [app, ...dependencies] = packages;
95857
95850
  const projectDir = await createTmpDirectory("go-run-on-already-downloaded-packages-");
95858
95851
  try {
@@ -96614,7 +96607,6 @@ var treeSitterRustPath = join16(REPOS_PATH(), "tree-sitter", "tree-sitter-rust")
96614
96607
 
96615
96608
  // dist/whole-program-code-aware-vulnerability-scanner/rust/rust-code-aware-vulnerability-scanner.js
96616
96609
  var import_picomatch3 = __toESM(require_picomatch4(), 1);
96617
- import assert7 from "node:assert";
96618
96610
  var { uniq: uniq6, uniqWith: uniqWith3, isEqual: isEqual3 } = import_lodash12.default;
96619
96611
  var RustCodeAwareVulnerabilityScanner = class _RustCodeAwareVulnerabilityScanner {
96620
96612
  apps;
@@ -96869,10 +96861,9 @@ async function convertDependencyChain3(dependencyChain, tmpDir) {
96869
96861
  return [depCrateInfo.lib];
96870
96862
  }
96871
96863
  const rustDependencyChain = await asyncMap(dependencyChain, async (dep) => {
96872
- assert7(dep.version);
96873
96864
  return {
96874
96865
  ...dep,
96875
- src: await downloadAndExtractCargoCrate2(dep.packageName, dep.version)
96866
+ src: dep.version ? await downloadAndExtractCargoCrate2(dep.packageName, dep.version) : void 0
96876
96867
  };
96877
96868
  }, 4);
96878
96869
  return rustDependencyChain;
@@ -96974,7 +96965,6 @@ async function convertSocketArtifacts3(artifacts, tmpDir) {
96974
96965
  const deps = {};
96975
96966
  const depIdToPackageMap = {};
96976
96967
  await asyncForEach(artifacts, async (artifact) => {
96977
- assert7(artifact.version);
96978
96968
  const uuid = randomUUID3();
96979
96969
  depIdToPackageMap[uuid] = {
96980
96970
  name: artifact.name,
@@ -96985,7 +96975,7 @@ async function convertSocketArtifacts3(artifacts, tmpDir) {
96985
96975
  type: "RUST",
96986
96976
  crate: artifact.name.replaceAll("-", "_")
96987
96977
  },
96988
- src: await resolveCargoCrate(artifact.name, artifact.version)
96978
+ src: artifact.version ? await resolveCargoCrate(artifact.name, artifact.version) : void 0
96989
96979
  };
96990
96980
  }, 4);
96991
96981
  return { deps, depIdToPackageMap };
@@ -97185,6 +97175,14 @@ async function getVersion(analysisName) {
97185
97175
  // dist/whole-program-code-aware-vulnerability-scanner/python/python-code-aware-vulnerability-scanner.js
97186
97176
  var import_semver2 = __toESM(require_semver2(), 1);
97187
97177
  var { omit, once: once3, pick, sortedUniq, uniqBy } = import_lodash14.default;
97178
+ var memlimitWrapper = `import sys, runpy, resource
97179
+ if memory_limit := int(sys.argv.pop(1)):
97180
+ try:
97181
+ resource.setrlimit(resource.RLIMIT_AS, (memory_limit * 1024 ** 2, -1))
97182
+ except ValueError as e:
97183
+ print("ERROR: Failed to set memory limit", e, file=sys.stderr)
97184
+ runpy.run_module("mambalade", alter_sys=True)
97185
+ `;
97188
97186
  var PythonCodeAwareVulnerabilityScanner = class {
97189
97187
  state;
97190
97188
  projectDir;
@@ -97230,15 +97228,6 @@ var PythonCodeAwareVulnerabilityScanner = class {
97230
97228
  const packagesToExclude = heuristic.getPackagesToExcludeFromAnalysis?.(vulns);
97231
97229
  const vulnAccPaths = sortedUniq(vulns.flatMap((v) => v.vulnerabilityAccessPaths).sort());
97232
97230
  const tmpDir = await createTmpDirectory("coana-mambalade-output");
97233
- const wrapperPath = join17(tmpDir, "wrapper.py");
97234
- await writeFile8(wrapperPath, `import sys, runpy, resource
97235
- if memory_limit := int(sys.argv.pop(1)):
97236
- try:
97237
- resource.setrlimit(resource.RLIMIT_AS, (memory_limit * 1024 ** 2, -1))
97238
- except ValueError as e:
97239
- print("ERROR: Failed to set memory limit", e, file=sys.stderr)
97240
- runpy.run_module("mambalade", alter_sys=True)
97241
- `);
97242
97231
  const vulnsOutputFile = join17(tmpDir, "vulns.json");
97243
97232
  const diagnosticsOutputFile = join17(tmpDir, "diagnostics.json");
97244
97233
  const excludeDistributionsOption = packagesToExclude?.size ? ["--exclude-distributions", ...packagesToExclude] : [];
@@ -97247,7 +97236,7 @@ runpy.run_module("mambalade", alter_sys=True)
97247
97236
  const pythonExecutable = join17(this.mambaladeVenvPath, "bin", "python");
97248
97237
  const mambaladeArgs = [
97249
97238
  pythonExecutable,
97250
- wrapperPath,
97239
+ "-",
97251
97240
  `${reachabilityAnalysisOptions.memoryLimitInMB ?? 0}`,
97252
97241
  "--vulnerabilities",
97253
97242
  ...vulnAccPaths,
@@ -97271,7 +97260,7 @@ ${vulnAccPaths.join("\n")}`);
97271
97260
  logger.debug(`Running python executable: ${pythonExecutable}`);
97272
97261
  logger.debug(`With args: ${mambaladeArgs.slice(1).join(" ")}`);
97273
97262
  try {
97274
- const { stderr } = await exec(mambaladeArgs, this.projectDir);
97263
+ const { stderr } = await exec(mambaladeArgs, this.projectDir, { stdin: memlimitWrapper });
97275
97264
  logger.debug("Done running mambalade");
97276
97265
  const errors = stderr.split("\n").filter((line) => line.startsWith("ERROR:") && !/^ERROR: Excluded distribution/.test(line));
97277
97266
  if (errors.length > 0)
@@ -97371,7 +97360,7 @@ ${msg}`;
97371
97360
  });
97372
97361
  }
97373
97362
  static async runOnDependencyChain(chain, vuln, options) {
97374
- assert8(chain.every((dep) => dep.version));
97363
+ assert5(chain.every((dep) => dep.version));
97375
97364
  const [first2, ...rest] = chain;
97376
97365
  return withTmpDirectory("python-run-on-dep-chain", async (tmpDir) => {
97377
97366
  const scanner = new this({
@@ -97510,7 +97499,7 @@ ${msg}`;
97510
97499
  async updateVirtualEnvInfo(virtualEnvFolder, packageInstallationStats) {
97511
97500
  const entries = await readdir3(join17(virtualEnvFolder, ".venv", "lib"));
97512
97501
  const pydir = entries.find((entry) => entry.startsWith("python"));
97513
- assert8(pydir, `No python* directory found in virtual environment: ${util5.inspect(entries)}`);
97502
+ assert5(pydir, `No python* directory found in virtual environment: ${util5.inspect(entries)}`);
97514
97503
  this.virtualEnvInfo = {
97515
97504
  virtualEnvFolder,
97516
97505
  virtualEnvPathToSitePackages: `${virtualEnvFolder}/.venv/lib/${pydir}/site-packages`,
@@ -97710,7 +97699,7 @@ var PipAnalyzer = class {
97710
97699
  });
97711
97700
  async runPhantomDependencyAnalysis() {
97712
97701
  const info = (await this.prepareScanner()).getVirtualEnvInfo();
97713
- assert9(info !== void 0);
97702
+ assert6(info !== void 0);
97714
97703
  const { subprojectDir, workspacePath, workspaceData } = this.state;
97715
97704
  let declaredDeps;
97716
97705
  if (workspaceData.type === "coana") {
@@ -97757,7 +97746,7 @@ var CLI_VERSION_TO_USE_CACHING_FROM = { PIP: "14.9.15" };
97757
97746
  var CLI_VERSION_TO_USE_CACHING_FROM_DEFAULT = "13.16.6";
97758
97747
  var SOCKET_MODE = process.env.SOCKET_MODE === "true";
97759
97748
  function assertVulnChainDetails(vs) {
97760
- assert10(vs.every((v) => v.vulnChainDetails));
97749
+ assert7(vs.every((v) => v.vulnChainDetails));
97761
97750
  }
97762
97751
  var apiKey = COANA_API_KEY ? { type: "present", value: COANA_API_KEY } : { type: "missing" };
97763
97752
  var dashboardAPI = new DashboardAPI(SOCKET_MODE, process.env.DISABLE_ANALYTICS_SHARING === "true");
@@ -98321,7 +98310,7 @@ var runReachabilityAnalysisCmd = new Command().name("runReachabilityAnalysis").a
98321
98310
  const result = await runReachabilityAnalysis(state);
98322
98311
  if (options.outputFile) {
98323
98312
  logger.debug("Writing result to file", options.outputFile);
98324
- await writeFile9(options.outputFile, JSON.stringify({ result }));
98313
+ await writeFile8(options.outputFile, JSON.stringify({ result }));
98325
98314
  } else {
98326
98315
  logger.info("Result:", JSON.stringify(result, null, 2));
98327
98316
  }
@@ -98331,7 +98320,7 @@ var runOnDependencyChainCmd = new Command().name("runOnDependencyChain").option(
98331
98320
  const result = await analyzePackages(ecosystem, deserializeDependencyChain(ecosystem, dependencyChain), vulnerability);
98332
98321
  if (options.outputFile) {
98333
98322
  logger.debug("Writing result to file", options.outputFile);
98334
- await writeFile9(options.outputFile, JSON.stringify({ result }));
98323
+ await writeFile8(options.outputFile, JSON.stringify({ result }));
98335
98324
  } else {
98336
98325
  logger.info("Result:", JSON.stringify(result, null, 2));
98337
98326
  }
@@ -98359,7 +98348,7 @@ var runOnPackageRegistryPackageCmd = new Command().name("runOnPackageRegistryPac
98359
98348
  const result = isFile3 ? await analyzeAlreadyInstalledPackages(options.ecosystem, [mainPackage, ...options.dependencies].map((p) => p.replace("file://", "")), vulnerability, { timeoutInSeconds: +options.analysisTimeout, memoryLimitInMB: +options.memoryLimit }) : await analyzePackages(options.ecosystem, deserializeDependencyChain(options.ecosystem, `${mainPackage}${options.dependencies.length > 0 ? ` > ${options.dependencies.join(" > ")}` : ""}`), vulnerability, { timeoutInSeconds: +options.analysisTimeout, memoryLimitInMB: +options.memoryLimit });
98360
98349
  if (options.outputFile) {
98361
98350
  logger.info("Writing result to file", options.outputFile);
98362
- await writeFile9(options.outputFile, JSON.stringify(result, null, 2));
98351
+ await writeFile8(options.outputFile, JSON.stringify(result, null, 2));
98363
98352
  } else {
98364
98353
  logger.info("Result:", JSON.stringify(result, null, 2));
98365
98354
  }