haansi 0.1.101 → 0.1.102

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.
Files changed (2) hide show
  1. package/dist/haansi.js +451 -392
  2. package/package.json +1 -1
package/dist/haansi.js CHANGED
@@ -95,7 +95,7 @@ var require_package = __commonJS({
95
95
  "package.json"(exports2, module2) {
96
96
  module2.exports = {
97
97
  name: "haansi",
98
- version: "0.1.101",
98
+ version: "0.1.102",
99
99
  description: "Haansi CLI - Session collector and MCP server for Claude Code & OpenAI Codex",
100
100
  bin: {
101
101
  haansi: "./dist/haansi.js"
@@ -3063,21 +3063,21 @@ var require_wink_porter2_stemmer = __commonJS({
3063
3063
  return s;
3064
3064
  };
3065
3065
  var stem2 = function(word) {
3066
- var str = word.toLowerCase();
3067
- if (str.length < 3) return str;
3068
- if (exceptions1[str]) return exceptions1[str];
3069
- str = prelude(str);
3070
- str = step1a(str);
3071
- if (!rgxException2.test(str)) {
3072
- str = step1b(str);
3073
- str = step1c(str);
3074
- str = step2(str);
3075
- str = step3(str);
3076
- str = step4(str);
3077
- str = step5(str);
3078
- }
3079
- str = str.replace(/3/g, "y");
3080
- return str;
3066
+ var str2 = word.toLowerCase();
3067
+ if (str2.length < 3) return str2;
3068
+ if (exceptions1[str2]) return exceptions1[str2];
3069
+ str2 = prelude(str2);
3070
+ str2 = step1a(str2);
3071
+ if (!rgxException2.test(str2)) {
3072
+ str2 = step1b(str2);
3073
+ str2 = step1c(str2);
3074
+ str2 = step2(str2);
3075
+ str2 = step3(str2);
3076
+ str2 = step4(str2);
3077
+ str2 = step5(str2);
3078
+ }
3079
+ str2 = str2.replace(/3/g, "y");
3080
+ return str2;
3081
3081
  };
3082
3082
  module2.exports = stem2;
3083
3083
  }
@@ -3991,13 +3991,13 @@ var require_ms = __commonJS({
3991
3991
  "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
3992
3992
  );
3993
3993
  };
3994
- function parse4(str) {
3995
- str = String(str);
3996
- if (str.length > 100) {
3994
+ function parse4(str2) {
3995
+ str2 = String(str2);
3996
+ if (str2.length > 100) {
3997
3997
  return;
3998
3998
  }
3999
3999
  var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
4000
- str
4000
+ str2
4001
4001
  );
4002
4002
  if (!match) {
4003
4003
  return;
@@ -10189,21 +10189,21 @@ var require_lib = __commonJS({
10189
10189
  3793,
10190
10190
  7920
10191
10191
  ];
10192
- var toUTF8Array = function toUTF8Array2(str) {
10192
+ var toUTF8Array = function toUTF8Array2(str2) {
10193
10193
  var char;
10194
10194
  var i = 0;
10195
10195
  var p = 0;
10196
10196
  var utf82 = [];
10197
- var len = str.length;
10197
+ var len = str2.length;
10198
10198
  for (; i < len; i++) {
10199
- char = str.charCodeAt(i);
10199
+ char = str2.charCodeAt(i);
10200
10200
  if (char < 128) {
10201
10201
  utf82[p++] = char;
10202
10202
  } else if (char < 2048) {
10203
10203
  utf82[p++] = char >> 6 | 192;
10204
10204
  utf82[p++] = char & 63 | 128;
10205
- } else if ((char & 64512) === 55296 && i + 1 < str.length && (str.charCodeAt(i + 1) & 64512) === 56320) {
10206
- char = 65536 + ((char & 1023) << 10) + (str.charCodeAt(++i) & 1023);
10205
+ } else if ((char & 64512) === 55296 && i + 1 < str2.length && (str2.charCodeAt(i + 1) & 64512) === 56320) {
10206
+ char = 65536 + ((char & 1023) << 10) + (str2.charCodeAt(++i) & 1023);
10207
10207
  utf82[p++] = char >> 18 | 240;
10208
10208
  utf82[p++] = char >> 12 & 63 | 128;
10209
10209
  utf82[p++] = char >> 6 & 63 | 128;
@@ -10216,13 +10216,13 @@ var require_lib = __commonJS({
10216
10216
  }
10217
10217
  return utf82;
10218
10218
  };
10219
- var generate = module2.exports = function generate2(str) {
10219
+ var generate = module2.exports = function generate2(str2) {
10220
10220
  var char;
10221
10221
  var i = 0;
10222
10222
  var start = -1;
10223
10223
  var result = 0;
10224
10224
  var resultHash = 0;
10225
- var utf82 = typeof str === "string" ? toUTF8Array(str) : str;
10225
+ var utf82 = typeof str2 === "string" ? toUTF8Array(str2) : str2;
10226
10226
  var len = utf82.length;
10227
10227
  while (i < len) {
10228
10228
  char = utf82[i++];
@@ -11111,7 +11111,7 @@ var require_node = __commonJS({
11111
11111
  var { formatters } = module2.exports;
11112
11112
  formatters.o = function(v) {
11113
11113
  this.inspectOpts.colors = this.useColors;
11114
- return util2.inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
11114
+ return util2.inspect(v, this.inspectOpts).split("\n").map((str2) => str2.trim()).join(" ");
11115
11115
  };
11116
11116
  formatters.O = function(v) {
11117
11117
  this.inspectOpts.colors = this.useColors;
@@ -11167,9 +11167,9 @@ var require_debug2 = __commonJS({
11167
11167
  }
11168
11168
  }
11169
11169
  exports2.getStringValue = getStringValue;
11170
- function genRedactedString(str, maxLen) {
11171
- const { length } = str;
11172
- return length <= maxLen ? str : str.slice(0, maxLen) + ' ... <REDACTED full-length="' + length + '">';
11170
+ function genRedactedString(str2, maxLen) {
11171
+ const { length } = str2;
11172
+ return length <= maxLen ? str2 : str2.slice(0, maxLen) + ' ... <REDACTED full-length="' + length + '">';
11173
11173
  }
11174
11174
  exports2.genRedactedString = genRedactedString;
11175
11175
  function genDebugFunction(namespace) {
@@ -11179,9 +11179,9 @@ var require_debug2 = __commonJS({
11179
11179
  return;
11180
11180
  }
11181
11181
  for (let i = 1; i < args.length; i++) {
11182
- const str = getStringValue(args[i]);
11183
- if (typeof str === "string" && str.length > MAX_ARGUMENT_LENGTH) {
11184
- args[i] = genRedactedString(str, MAX_ARGUMENT_LENGTH);
11182
+ const str2 = getStringValue(args[i]);
11183
+ if (typeof str2 === "string" && str2.length > MAX_ARGUMENT_LENGTH) {
11184
+ args[i] = genRedactedString(str2, MAX_ARGUMENT_LENGTH);
11185
11185
  }
11186
11186
  }
11187
11187
  return fn.apply(null, args);
@@ -20969,20 +20969,20 @@ var require_utils3 = __commonJS({
20969
20969
  }
20970
20970
  return config6;
20971
20971
  }
20972
- var escapeIdentifier2 = function(str) {
20973
- return '"' + str.replace(/"/g, '""') + '"';
20972
+ var escapeIdentifier2 = function(str2) {
20973
+ return '"' + str2.replace(/"/g, '""') + '"';
20974
20974
  };
20975
- var escapeLiteral2 = function(str) {
20975
+ var escapeLiteral2 = function(str2) {
20976
20976
  let hasBackslash = false;
20977
20977
  let escaped = "'";
20978
- if (str == null) {
20978
+ if (str2 == null) {
20979
20979
  return "''";
20980
20980
  }
20981
- if (typeof str !== "string") {
20981
+ if (typeof str2 !== "string") {
20982
20982
  return "''";
20983
20983
  }
20984
- for (let i = 0; i < str.length; i++) {
20985
- const c = str[i];
20984
+ for (let i = 0; i < str2.length; i++) {
20985
+ const c = str2[i];
20986
20986
  if (c === "'") {
20987
20987
  escaped += c + c;
20988
20988
  } else if (c === "\\") {
@@ -21431,22 +21431,22 @@ var require_pg_connection_string = __commonJS({
21431
21431
  "../../node_modules/pg-connection-string/index.js"(exports2, module2) {
21432
21432
  "use strict";
21433
21433
  var { emitWarning } = require("node:process");
21434
- function parse4(str, options = {}) {
21435
- if (str.charAt(0) === "/") {
21436
- const config7 = str.split(" ");
21434
+ function parse4(str2, options = {}) {
21435
+ if (str2.charAt(0) === "/") {
21436
+ const config7 = str2.split(" ");
21437
21437
  return { host: config7[0], database: config7[1] };
21438
21438
  }
21439
21439
  const config6 = {};
21440
21440
  let result;
21441
21441
  let dummyHost = false;
21442
- if (/ |%[^a-f0-9]|%[a-f0-9][^a-f0-9]/i.test(str)) {
21443
- str = encodeURI(str).replace(/%25(\d\d)/g, "%$1");
21442
+ if (/ |%[^a-f0-9]|%[a-f0-9][^a-f0-9]/i.test(str2)) {
21443
+ str2 = encodeURI(str2).replace(/%25(\d\d)/g, "%$1");
21444
21444
  }
21445
21445
  try {
21446
21446
  try {
21447
- result = new URL(str, "postgres://base");
21447
+ result = new URL(str2, "postgres://base");
21448
21448
  } catch (e) {
21449
- result = new URL(str.replace("@/", "@___DUMMY___/"), "postgres://base");
21449
+ result = new URL(str2.replace("@/", "@___DUMMY___/"), "postgres://base");
21450
21450
  dummyHost = true;
21451
21451
  }
21452
21452
  } catch (err2) {
@@ -21589,8 +21589,8 @@ var require_pg_connection_string = __commonJS({
21589
21589
  }, {});
21590
21590
  return poolConfig;
21591
21591
  }
21592
- function parseIntoClientConfig(str) {
21593
- return toClientConfig(parse4(str));
21592
+ function parseIntoClientConfig(str2) {
21593
+ return toClientConfig(parse4(str2));
21594
21594
  }
21595
21595
  function deprecatedSslModeWarning(sslmode) {
21596
21596
  if (!deprecatedSslModeWarning.warned) {
@@ -23883,11 +23883,11 @@ var require_client = __commonJS({
23883
23883
  // escapeIdentifier and escapeLiteral moved to utility functions & exported
23884
23884
  // on PG
23885
23885
  // re-exported here for backwards compatibility
23886
- escapeIdentifier(str) {
23887
- return utils.escapeIdentifier(str);
23886
+ escapeIdentifier(str2) {
23887
+ return utils.escapeIdentifier(str2);
23888
23888
  }
23889
- escapeLiteral(str) {
23890
- return utils.escapeLiteral(str);
23889
+ escapeLiteral(str2) {
23890
+ return utils.escapeLiteral(str2);
23891
23891
  }
23892
23892
  _pulseQueryQueue() {
23893
23893
  if (this.readyForQuery === true) {
@@ -29363,8 +29363,8 @@ var require_convert_expression = __commonJS({
29363
29363
  }
29364
29364
  return expressions;
29365
29365
  }
29366
- function removeSpaces(str) {
29367
- return str.replace(/\s{2,}/g, " ").trim();
29366
+ function removeSpaces(str2) {
29367
+ return str2.replace(/\s{2,}/g, " ").trim();
29368
29368
  }
29369
29369
  function normalizeIntegers(expressions) {
29370
29370
  for (let i = 0; i < expressions.length; i++) {
@@ -29701,11 +29701,11 @@ var init_parse = __esm({
29701
29701
  });
29702
29702
 
29703
29703
  // ../../node_modules/node-cron/node_modules/uuid/dist/esm-node/v35.js
29704
- function stringToBytes(str) {
29705
- str = unescape(encodeURIComponent(str));
29704
+ function stringToBytes(str2) {
29705
+ str2 = unescape(encodeURIComponent(str2));
29706
29706
  const bytes = [];
29707
- for (let i = 0; i < str.length; ++i) {
29708
- bytes.push(str.charCodeAt(i));
29707
+ for (let i = 0; i < str2.length; ++i) {
29708
+ bytes.push(str2.charCodeAt(i));
29709
29709
  }
29710
29710
  return bytes;
29711
29711
  }
@@ -34483,14 +34483,14 @@ function promiseAllObject(promisesObj) {
34483
34483
  }
34484
34484
  function randomString(length = 10) {
34485
34485
  const chars = "abcdefghijklmnopqrstuvwxyz";
34486
- let str = "";
34486
+ let str2 = "";
34487
34487
  for (let i = 0; i < length; i++) {
34488
- str += chars[Math.floor(Math.random() * chars.length)];
34488
+ str2 += chars[Math.floor(Math.random() * chars.length)];
34489
34489
  }
34490
- return str;
34490
+ return str2;
34491
34491
  }
34492
- function esc(str) {
34493
- return JSON.stringify(str);
34492
+ function esc(str2) {
34493
+ return JSON.stringify(str2);
34494
34494
  }
34495
34495
  function slugify(input) {
34496
34496
  return input.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
@@ -34530,8 +34530,8 @@ function numKeys(data) {
34530
34530
  }
34531
34531
  return keyCount;
34532
34532
  }
34533
- function escapeRegex(str) {
34534
- return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
34533
+ function escapeRegex(str2) {
34534
+ return str2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
34535
34535
  }
34536
34536
  function clone(inst, def, params) {
34537
34537
  const cl = new inst._zod.constr(def ?? inst._zod.def);
@@ -46149,7 +46149,7 @@ var require_code = __commonJS({
46149
46149
  }
46150
46150
  exports2._ = _;
46151
46151
  var plus = new _Code("+");
46152
- function str(strs, ...args) {
46152
+ function str2(strs, ...args) {
46153
46153
  const expr = [safeStringify(strs[0])];
46154
46154
  let i = 0;
46155
46155
  while (i < args.length) {
@@ -46160,7 +46160,7 @@ var require_code = __commonJS({
46160
46160
  optimize(expr);
46161
46161
  return new _Code(expr);
46162
46162
  }
46163
- exports2.str = str;
46163
+ exports2.str = str2;
46164
46164
  function addCodeArg(code, arg) {
46165
46165
  if (arg instanceof _Code)
46166
46166
  code.push(...arg._items);
@@ -46203,7 +46203,7 @@ var require_code = __commonJS({
46203
46203
  return;
46204
46204
  }
46205
46205
  function strConcat(c1, c2) {
46206
- return c2.emptyStr() ? c1 : c1.emptyStr() ? c2 : str`${c1}${c2}`;
46206
+ return c2.emptyStr() ? c1 : c1.emptyStr() ? c2 : str2`${c1}${c2}`;
46207
46207
  }
46208
46208
  exports2.strConcat = strConcat;
46209
46209
  function interpolate(x) {
@@ -47165,22 +47165,22 @@ var require_util2 = __commonJS({
47165
47165
  return (0, codegen_1._)`${topSchemaRef}${schemaPath}${(0, codegen_1.getProperty)(keyword)}`;
47166
47166
  }
47167
47167
  exports2.schemaRefOrVal = schemaRefOrVal;
47168
- function unescapeFragment(str) {
47169
- return unescapeJsonPointer(decodeURIComponent(str));
47168
+ function unescapeFragment(str2) {
47169
+ return unescapeJsonPointer(decodeURIComponent(str2));
47170
47170
  }
47171
47171
  exports2.unescapeFragment = unescapeFragment;
47172
- function escapeFragment(str) {
47173
- return encodeURIComponent(escapeJsonPointer(str));
47172
+ function escapeFragment(str2) {
47173
+ return encodeURIComponent(escapeJsonPointer(str2));
47174
47174
  }
47175
47175
  exports2.escapeFragment = escapeFragment;
47176
- function escapeJsonPointer(str) {
47177
- if (typeof str == "number")
47178
- return `${str}`;
47179
- return str.replace(/~/g, "~0").replace(/\//g, "~1");
47176
+ function escapeJsonPointer(str2) {
47177
+ if (typeof str2 == "number")
47178
+ return `${str2}`;
47179
+ return str2.replace(/~/g, "~0").replace(/\//g, "~1");
47180
47180
  }
47181
47181
  exports2.escapeJsonPointer = escapeJsonPointer;
47182
- function unescapeJsonPointer(str) {
47183
- return str.replace(/~1/g, "/").replace(/~0/g, "~");
47182
+ function unescapeJsonPointer(str2) {
47183
+ return str2.replace(/~1/g, "/").replace(/~0/g, "~");
47184
47184
  }
47185
47185
  exports2.unescapeJsonPointer = unescapeJsonPointer;
47186
47186
  function eachItem(xs, f) {
@@ -48205,8 +48205,8 @@ var require_json_schema_traverse = __commonJS({
48205
48205
  post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
48206
48206
  }
48207
48207
  }
48208
- function escapeJsonPtr(str) {
48209
- return str.replace(/~/g, "~0").replace(/\//g, "~1");
48208
+ function escapeJsonPtr(str2) {
48209
+ return str2.replace(/~/g, "~0").replace(/\//g, "~1");
48210
48210
  }
48211
48211
  }
48212
48212
  });
@@ -49267,10 +49267,10 @@ var require_utils5 = __commonJS({
49267
49267
  return { host, isIPV6: false };
49268
49268
  }
49269
49269
  }
49270
- function findToken(str, token2) {
49270
+ function findToken(str2, token2) {
49271
49271
  let ind = 0;
49272
- for (let i = 0; i < str.length; i++) {
49273
- if (str[i] === token2) ind++;
49272
+ for (let i = 0; i < str2.length; i++) {
49273
+ if (str2[i] === token2) ind++;
49274
49274
  }
49275
49275
  return ind;
49276
49276
  }
@@ -49923,7 +49923,7 @@ var require_core = __commonJS({
49923
49923
  var util_1 = require_util2();
49924
49924
  var $dataRefSchema = require_data();
49925
49925
  var uri_1 = require_uri();
49926
- var defaultRegExp = (str, flags) => new RegExp(str, flags);
49926
+ var defaultRegExp = (str2, flags) => new RegExp(str2, flags);
49927
49927
  defaultRegExp.code = "new RegExp";
49928
49928
  var META_IGNORE_OPTIONS = ["removeAdditional", "useDefaults", "coerceTypes"];
49929
49929
  var EXT_SCOPE_NAMES = /* @__PURE__ */ new Set([
@@ -50718,16 +50718,16 @@ var require_ucs2length = __commonJS({
50718
50718
  "../service-capture/node_modules/ajv/dist/runtime/ucs2length.js"(exports2) {
50719
50719
  "use strict";
50720
50720
  Object.defineProperty(exports2, "__esModule", { value: true });
50721
- function ucs2length(str) {
50722
- const len = str.length;
50721
+ function ucs2length(str2) {
50722
+ const len = str2.length;
50723
50723
  let length = 0;
50724
50724
  let pos = 0;
50725
50725
  let value;
50726
50726
  while (pos < len) {
50727
50727
  length++;
50728
- value = str.charCodeAt(pos++);
50728
+ value = str2.charCodeAt(pos++);
50729
50729
  if (value >= 55296 && value <= 56319 && pos < len) {
50730
- value = str.charCodeAt(pos);
50730
+ value = str2.charCodeAt(pos);
50731
50731
  if ((value & 64512) === 56320)
50732
50732
  pos++;
50733
50733
  }
@@ -52610,8 +52610,8 @@ var require_formats = __commonJS({
52610
52610
  }
52611
52611
  var DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
52612
52612
  var DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
52613
- function date4(str) {
52614
- const matches = DATE.exec(str);
52613
+ function date4(str2) {
52614
+ const matches = DATE.exec(str2);
52615
52615
  if (!matches)
52616
52616
  return false;
52617
52617
  const year = +matches[1];
@@ -52630,8 +52630,8 @@ var require_formats = __commonJS({
52630
52630
  }
52631
52631
  var TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i;
52632
52632
  function getTime(strictTimeZone) {
52633
- return function time3(str) {
52634
- const matches = TIME.exec(str);
52633
+ return function time3(str2) {
52634
+ const matches = TIME.exec(str2);
52635
52635
  if (!matches)
52636
52636
  return false;
52637
52637
  const hr = +matches[1];
@@ -52677,8 +52677,8 @@ var require_formats = __commonJS({
52677
52677
  var DATE_TIME_SEPARATOR = /t|\s/i;
52678
52678
  function getDateTime(strictTimeZone) {
52679
52679
  const time3 = getTime(strictTimeZone);
52680
- return function date_time(str) {
52681
- const dateTime = str.split(DATE_TIME_SEPARATOR);
52680
+ return function date_time(str2) {
52681
+ const dateTime = str2.split(DATE_TIME_SEPARATOR);
52682
52682
  return dateTime.length === 2 && date4(dateTime[0]) && time3(dateTime[1]);
52683
52683
  };
52684
52684
  }
@@ -52703,13 +52703,13 @@ var require_formats = __commonJS({
52703
52703
  }
52704
52704
  var NOT_URI_FRAGMENT = /\/|:/;
52705
52705
  var URI = /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
52706
- function uri(str) {
52707
- return NOT_URI_FRAGMENT.test(str) && URI.test(str);
52706
+ function uri(str2) {
52707
+ return NOT_URI_FRAGMENT.test(str2) && URI.test(str2);
52708
52708
  }
52709
52709
  var BYTE = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/gm;
52710
- function byte(str) {
52710
+ function byte(str2) {
52711
52711
  BYTE.lastIndex = 0;
52712
- return BYTE.test(str);
52712
+ return BYTE.test(str2);
52713
52713
  }
52714
52714
  var MIN_INT32 = -(2 ** 31);
52715
52715
  var MAX_INT32 = 2 ** 31 - 1;
@@ -52723,11 +52723,11 @@ var require_formats = __commonJS({
52723
52723
  return true;
52724
52724
  }
52725
52725
  var Z_ANCHOR = /[^\\]\\Z/;
52726
- function regex(str) {
52727
- if (Z_ANCHOR.test(str))
52726
+ function regex(str2) {
52727
+ if (Z_ANCHOR.test(str2))
52728
52728
  return false;
52729
52729
  try {
52730
- new RegExp(str);
52730
+ new RegExp(str2);
52731
52731
  return true;
52732
52732
  } catch (e) {
52733
52733
  return false;
@@ -52804,7 +52804,7 @@ var require_code3 = __commonJS({
52804
52804
  }
52805
52805
  exports2._ = _;
52806
52806
  var plus = new _Code("+");
52807
- function str(strs, ...args) {
52807
+ function str2(strs, ...args) {
52808
52808
  const expr = [safeStringify(strs[0])];
52809
52809
  let i = 0;
52810
52810
  while (i < args.length) {
@@ -52815,7 +52815,7 @@ var require_code3 = __commonJS({
52815
52815
  optimize(expr);
52816
52816
  return new _Code(expr);
52817
52817
  }
52818
- exports2.str = str;
52818
+ exports2.str = str2;
52819
52819
  function addCodeArg(code, arg) {
52820
52820
  if (arg instanceof _Code)
52821
52821
  code.push(...arg._items);
@@ -52858,7 +52858,7 @@ var require_code3 = __commonJS({
52858
52858
  return;
52859
52859
  }
52860
52860
  function strConcat(c1, c2) {
52861
- return c2.emptyStr() ? c1 : c1.emptyStr() ? c2 : str`${c1}${c2}`;
52861
+ return c2.emptyStr() ? c1 : c1.emptyStr() ? c2 : str2`${c1}${c2}`;
52862
52862
  }
52863
52863
  exports2.strConcat = strConcat;
52864
52864
  function interpolate(x) {
@@ -53820,22 +53820,22 @@ var require_util3 = __commonJS({
53820
53820
  return (0, codegen_1._)`${topSchemaRef}${schemaPath}${(0, codegen_1.getProperty)(keyword)}`;
53821
53821
  }
53822
53822
  exports2.schemaRefOrVal = schemaRefOrVal;
53823
- function unescapeFragment(str) {
53824
- return unescapeJsonPointer(decodeURIComponent(str));
53823
+ function unescapeFragment(str2) {
53824
+ return unescapeJsonPointer(decodeURIComponent(str2));
53825
53825
  }
53826
53826
  exports2.unescapeFragment = unescapeFragment;
53827
- function escapeFragment(str) {
53828
- return encodeURIComponent(escapeJsonPointer(str));
53827
+ function escapeFragment(str2) {
53828
+ return encodeURIComponent(escapeJsonPointer(str2));
53829
53829
  }
53830
53830
  exports2.escapeFragment = escapeFragment;
53831
- function escapeJsonPointer(str) {
53832
- if (typeof str == "number")
53833
- return `${str}`;
53834
- return str.replace(/~/g, "~0").replace(/\//g, "~1");
53831
+ function escapeJsonPointer(str2) {
53832
+ if (typeof str2 == "number")
53833
+ return `${str2}`;
53834
+ return str2.replace(/~/g, "~0").replace(/\//g, "~1");
53835
53835
  }
53836
53836
  exports2.escapeJsonPointer = escapeJsonPointer;
53837
- function unescapeJsonPointer(str) {
53838
- return str.replace(/~1/g, "/").replace(/~0/g, "~");
53837
+ function unescapeJsonPointer(str2) {
53838
+ return str2.replace(/~1/g, "/").replace(/~0/g, "~");
53839
53839
  }
53840
53840
  exports2.unescapeJsonPointer = unescapeJsonPointer;
53841
53841
  function eachItem(xs, f) {
@@ -54825,8 +54825,8 @@ var require_json_schema_traverse2 = __commonJS({
54825
54825
  post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
54826
54826
  }
54827
54827
  }
54828
- function escapeJsonPtr(str) {
54829
- return str.replace(/~/g, "~0").replace(/\//g, "~1");
54828
+ function escapeJsonPtr(str2) {
54829
+ return str2.replace(/~/g, "~0").replace(/\//g, "~1");
54830
54830
  }
54831
54831
  }
54832
54832
  });
@@ -55821,7 +55821,7 @@ var require_core3 = __commonJS({
55821
55821
  var util_1 = require_util3();
55822
55822
  var $dataRefSchema = require_data2();
55823
55823
  var uri_1 = require_uri2();
55824
- var defaultRegExp = (str, flags) => new RegExp(str, flags);
55824
+ var defaultRegExp = (str2, flags) => new RegExp(str2, flags);
55825
55825
  defaultRegExp.code = "new RegExp";
55826
55826
  var META_IGNORE_OPTIONS = ["removeAdditional", "useDefaults", "coerceTypes"];
55827
55827
  var EXT_SCOPE_NAMES = /* @__PURE__ */ new Set([
@@ -56616,16 +56616,16 @@ var require_ucs2length2 = __commonJS({
56616
56616
  "../../node_modules/ajv-formats/node_modules/ajv/dist/runtime/ucs2length.js"(exports2) {
56617
56617
  "use strict";
56618
56618
  Object.defineProperty(exports2, "__esModule", { value: true });
56619
- function ucs2length(str) {
56620
- const len = str.length;
56619
+ function ucs2length(str2) {
56620
+ const len = str2.length;
56621
56621
  let length = 0;
56622
56622
  let pos = 0;
56623
56623
  let value;
56624
56624
  while (pos < len) {
56625
56625
  length++;
56626
- value = str.charCodeAt(pos++);
56626
+ value = str2.charCodeAt(pos++);
56627
56627
  if (value >= 55296 && value <= 56319 && pos < len) {
56628
- value = str.charCodeAt(pos);
56628
+ value = str2.charCodeAt(pos);
56629
56629
  if ((value & 64512) === 56320)
56630
56630
  pos++;
56631
56631
  }
@@ -60139,8 +60139,8 @@ var require_depd = __commonJS({
60139
60139
  var relative4 = require("path").relative;
60140
60140
  module2.exports = depd;
60141
60141
  var basePath = process.cwd();
60142
- function containsNamespace(str, namespace) {
60143
- var vals = str.split(/[ ,]+/);
60142
+ function containsNamespace(str2, namespace) {
60143
+ var vals = str2.split(/[ ,]+/);
60144
60144
  var ns = String(namespace).toLowerCase();
60145
60145
  for (var i = 0; i < vals.length; i++) {
60146
60146
  var val = vals[i];
@@ -60167,21 +60167,21 @@ var require_depd = __commonJS({
60167
60167
  return descriptor;
60168
60168
  }
60169
60169
  function createArgumentsString(arity) {
60170
- var str = "";
60170
+ var str2 = "";
60171
60171
  for (var i = 0; i < arity; i++) {
60172
- str += ", arg" + i;
60172
+ str2 += ", arg" + i;
60173
60173
  }
60174
- return str.substr(2);
60174
+ return str2.substr(2);
60175
60175
  }
60176
60176
  function createStackString(stack) {
60177
- var str = this.name + ": " + this.namespace;
60177
+ var str2 = this.name + ": " + this.namespace;
60178
60178
  if (this.message) {
60179
- str += " deprecated " + this.message;
60179
+ str2 += " deprecated " + this.message;
60180
60180
  }
60181
60181
  for (var i = 0; i < stack.length; i++) {
60182
- str += "\n at " + stack[i].toString();
60182
+ str2 += "\n at " + stack[i].toString();
60183
60183
  }
60184
- return str;
60184
+ return str2;
60185
60185
  }
60186
60186
  function depd(namespace) {
60187
60187
  if (!namespace) {
@@ -60210,15 +60210,15 @@ var require_depd = __commonJS({
60210
60210
  if (process.noDeprecation) {
60211
60211
  return true;
60212
60212
  }
60213
- var str = process.env.NO_DEPRECATION || "";
60214
- return containsNamespace(str, namespace);
60213
+ var str2 = process.env.NO_DEPRECATION || "";
60214
+ return containsNamespace(str2, namespace);
60215
60215
  }
60216
60216
  function istraced(namespace) {
60217
60217
  if (process.traceDeprecation) {
60218
60218
  return true;
60219
60219
  }
60220
- var str = process.env.TRACE_DEPRECATION || "";
60221
- return containsNamespace(str, namespace);
60220
+ var str2 = process.env.TRACE_DEPRECATION || "";
60221
+ return containsNamespace(str2, namespace);
60222
60222
  }
60223
60223
  function log(message, site) {
60224
60224
  var haslisteners = eehaslisteners(process, "deprecation");
@@ -60652,8 +60652,8 @@ var require_toidentifier = __commonJS({
60652
60652
  "../../node_modules/toidentifier/index.js"(exports2, module2) {
60653
60653
  "use strict";
60654
60654
  module2.exports = toIdentifier;
60655
- function toIdentifier(str) {
60656
- return str.split(" ").map(function(token2) {
60655
+ function toIdentifier(str2) {
60656
+ return str2.split(" ").map(function(token2) {
60657
60657
  return token2.slice(0, 1).toUpperCase() + token2.slice(1);
60658
60658
  }).join("").replace(/[^ _0-9a-z]/gi, "");
60659
60659
  }
@@ -60877,16 +60877,16 @@ var require_bytes = __commonJS({
60877
60877
  }
60878
60878
  }
60879
60879
  var val = value / map2[unit.toLowerCase()];
60880
- var str = val.toFixed(decimalPlaces);
60880
+ var str2 = val.toFixed(decimalPlaces);
60881
60881
  if (!fixedDecimals) {
60882
- str = str.replace(formatDecimalsRegExp, "$1");
60882
+ str2 = str2.replace(formatDecimalsRegExp, "$1");
60883
60883
  }
60884
60884
  if (thousandsSeparator) {
60885
- str = str.split(".").map(function(s, i) {
60885
+ str2 = str2.split(".").map(function(s, i) {
60886
60886
  return i === 0 ? s.replace(formatThousandsRegExp, thousandsSeparator) : s;
60887
60887
  }).join(".");
60888
60888
  }
60889
- return str + unitSeparator + unit;
60889
+ return str2 + unitSeparator + unit;
60890
60890
  }
60891
60891
  function parse4(val) {
60892
60892
  if (typeof val === "number" && !isNaN(val)) {
@@ -60991,12 +60991,12 @@ var require_bom_handling = __commonJS({
60991
60991
  this.encoder = encoder;
60992
60992
  this.addBOM = true;
60993
60993
  }
60994
- PrependBOMWrapper.prototype.write = function(str) {
60994
+ PrependBOMWrapper.prototype.write = function(str2) {
60995
60995
  if (this.addBOM) {
60996
- str = BOMChar + str;
60996
+ str2 = BOMChar + str2;
60997
60997
  this.addBOM = false;
60998
60998
  }
60999
- return this.encoder.write(str);
60999
+ return this.encoder.write(str2);
61000
61000
  };
61001
61001
  PrependBOMWrapper.prototype.end = function() {
61002
61002
  return this.encoder.end();
@@ -61095,31 +61095,31 @@ var require_internal = __commonJS({
61095
61095
  function InternalEncoder(options, codec2) {
61096
61096
  this.enc = codec2.enc;
61097
61097
  }
61098
- InternalEncoder.prototype.write = function(str) {
61099
- return Buffer2.from(str, this.enc);
61098
+ InternalEncoder.prototype.write = function(str2) {
61099
+ return Buffer2.from(str2, this.enc);
61100
61100
  };
61101
61101
  InternalEncoder.prototype.end = function() {
61102
61102
  };
61103
61103
  function InternalEncoderBase64(options, codec2) {
61104
61104
  this.prevStr = "";
61105
61105
  }
61106
- InternalEncoderBase64.prototype.write = function(str) {
61107
- str = this.prevStr + str;
61108
- var completeQuads = str.length - str.length % 4;
61109
- this.prevStr = str.slice(completeQuads);
61110
- str = str.slice(0, completeQuads);
61111
- return Buffer2.from(str, "base64");
61106
+ InternalEncoderBase64.prototype.write = function(str2) {
61107
+ str2 = this.prevStr + str2;
61108
+ var completeQuads = str2.length - str2.length % 4;
61109
+ this.prevStr = str2.slice(completeQuads);
61110
+ str2 = str2.slice(0, completeQuads);
61111
+ return Buffer2.from(str2, "base64");
61112
61112
  };
61113
61113
  InternalEncoderBase64.prototype.end = function() {
61114
61114
  return Buffer2.from(this.prevStr, "base64");
61115
61115
  };
61116
61116
  function InternalEncoderCesu8(options, codec2) {
61117
61117
  }
61118
- InternalEncoderCesu8.prototype.write = function(str) {
61119
- var buf = Buffer2.alloc(str.length * 3);
61118
+ InternalEncoderCesu8.prototype.write = function(str2) {
61119
+ var buf = Buffer2.alloc(str2.length * 3);
61120
61120
  var bufIdx = 0;
61121
- for (var i = 0; i < str.length; i++) {
61122
- var charCode = str.charCodeAt(i);
61121
+ for (var i = 0; i < str2.length; i++) {
61122
+ var charCode = str2.charCodeAt(i);
61123
61123
  if (charCode < 128) {
61124
61124
  buf[bufIdx++] = charCode;
61125
61125
  } else if (charCode < 2048) {
@@ -61200,25 +61200,25 @@ var require_internal = __commonJS({
61200
61200
  function InternalEncoderUtf8(options, codec2) {
61201
61201
  this.highSurrogate = "";
61202
61202
  }
61203
- InternalEncoderUtf8.prototype.write = function(str) {
61203
+ InternalEncoderUtf8.prototype.write = function(str2) {
61204
61204
  if (this.highSurrogate) {
61205
- str = this.highSurrogate + str;
61205
+ str2 = this.highSurrogate + str2;
61206
61206
  this.highSurrogate = "";
61207
61207
  }
61208
- if (str.length > 0) {
61209
- var charCode = str.charCodeAt(str.length - 1);
61208
+ if (str2.length > 0) {
61209
+ var charCode = str2.charCodeAt(str2.length - 1);
61210
61210
  if (charCode >= 55296 && charCode < 56320) {
61211
- this.highSurrogate = str[str.length - 1];
61212
- str = str.slice(0, str.length - 1);
61211
+ this.highSurrogate = str2[str2.length - 1];
61212
+ str2 = str2.slice(0, str2.length - 1);
61213
61213
  }
61214
61214
  }
61215
- return Buffer2.from(str, this.enc);
61215
+ return Buffer2.from(str2, this.enc);
61216
61216
  };
61217
61217
  InternalEncoderUtf8.prototype.end = function() {
61218
61218
  if (this.highSurrogate) {
61219
- var str = this.highSurrogate;
61219
+ var str2 = this.highSurrogate;
61220
61220
  this.highSurrogate = "";
61221
- return Buffer2.from(str, this.enc);
61221
+ return Buffer2.from(str2, this.enc);
61222
61222
  }
61223
61223
  };
61224
61224
  }
@@ -61245,8 +61245,8 @@ var require_utf32 = __commonJS({
61245
61245
  this.isLE = codec2.isLE;
61246
61246
  this.highSurrogate = 0;
61247
61247
  }
61248
- Utf32Encoder.prototype.write = function(str) {
61249
- var src = Buffer2.from(str, "ucs2");
61248
+ Utf32Encoder.prototype.write = function(str2) {
61249
+ var src = Buffer2.from(str2, "ucs2");
61250
61250
  var dst = Buffer2.alloc(src.length * 2);
61251
61251
  var write32 = this.isLE ? dst.writeUInt32LE : dst.writeUInt32BE;
61252
61252
  var offset = 0;
@@ -61367,8 +61367,8 @@ var require_utf32 = __commonJS({
61367
61367
  }
61368
61368
  this.encoder = codec2.iconv.getEncoder(options.defaultEncoding || "utf-32le", options);
61369
61369
  }
61370
- Utf32AutoEncoder.prototype.write = function(str) {
61371
- return this.encoder.write(str);
61370
+ Utf32AutoEncoder.prototype.write = function(str2) {
61371
+ return this.encoder.write(str2);
61372
61372
  };
61373
61373
  Utf32AutoEncoder.prototype.end = function() {
61374
61374
  return this.encoder.end();
@@ -61468,8 +61468,8 @@ var require_utf16 = __commonJS({
61468
61468
  Utf16BECodec.prototype.bomAware = true;
61469
61469
  function Utf16BEEncoder() {
61470
61470
  }
61471
- Utf16BEEncoder.prototype.write = function(str) {
61472
- var buf = Buffer2.from(str, "ucs2");
61471
+ Utf16BEEncoder.prototype.write = function(str2) {
61472
+ var buf = Buffer2.from(str2, "ucs2");
61473
61473
  for (var i = 0; i < buf.length; i += 2) {
61474
61474
  var tmp = buf[i];
61475
61475
  buf[i] = buf[i + 1];
@@ -61518,8 +61518,8 @@ var require_utf16 = __commonJS({
61518
61518
  }
61519
61519
  this.encoder = codec2.iconv.getEncoder("utf-16le", options);
61520
61520
  }
61521
- Utf16Encoder.prototype.write = function(str) {
61522
- return this.encoder.write(str);
61521
+ Utf16Encoder.prototype.write = function(str2) {
61522
+ return this.encoder.write(str2);
61523
61523
  };
61524
61524
  Utf16Encoder.prototype.end = function() {
61525
61525
  return this.encoder.end();
@@ -61615,8 +61615,8 @@ var require_utf7 = __commonJS({
61615
61615
  function Utf7Encoder(options, codec2) {
61616
61616
  this.iconv = codec2.iconv;
61617
61617
  }
61618
- Utf7Encoder.prototype.write = function(str) {
61619
- return Buffer2.from(str.replace(nonDirectChars, function(chunk) {
61618
+ Utf7Encoder.prototype.write = function(str2) {
61619
+ return Buffer2.from(str2.replace(nonDirectChars, function(chunk) {
61620
61620
  return "+" + (chunk === "+" ? "" : this.iconv.encode(chunk, "utf16-be").toString("base64").replace(/=+$/, "")) + "-";
61621
61621
  }.bind(this)));
61622
61622
  };
@@ -61700,14 +61700,14 @@ var require_utf7 = __commonJS({
61700
61700
  this.base64Accum = Buffer2.alloc(6);
61701
61701
  this.base64AccumIdx = 0;
61702
61702
  }
61703
- Utf7IMAPEncoder.prototype.write = function(str) {
61703
+ Utf7IMAPEncoder.prototype.write = function(str2) {
61704
61704
  var inBase64 = this.inBase64;
61705
61705
  var base64Accum = this.base64Accum;
61706
61706
  var base64AccumIdx = this.base64AccumIdx;
61707
- var buf = Buffer2.alloc(str.length * 5 + 10);
61707
+ var buf = Buffer2.alloc(str2.length * 5 + 10);
61708
61708
  var bufIdx = 0;
61709
- for (var i2 = 0; i2 < str.length; i2++) {
61710
- var uChar = str.charCodeAt(i2);
61709
+ for (var i2 = 0; i2 < str2.length; i2++) {
61710
+ var uChar = str2.charCodeAt(i2);
61711
61711
  if (uChar >= 32 && uChar <= 126) {
61712
61712
  if (inBase64) {
61713
61713
  if (base64AccumIdx > 0) {
@@ -61848,10 +61848,10 @@ var require_sbcs_codec = __commonJS({
61848
61848
  function SBCSEncoder(options, codec2) {
61849
61849
  this.encodeBuf = codec2.encodeBuf;
61850
61850
  }
61851
- SBCSEncoder.prototype.write = function(str) {
61852
- var buf = Buffer2.alloc(str.length);
61853
- for (var i = 0; i < str.length; i++) {
61854
- buf[i] = this.encodeBuf[str.charCodeAt(i)];
61851
+ SBCSEncoder.prototype.write = function(str2) {
61852
+ var buf = Buffer2.alloc(str2.length);
61853
+ for (var i = 0; i < str2.length; i++) {
61854
+ buf[i] = this.encodeBuf[str2.charCodeAt(i)];
61855
61855
  }
61856
61856
  return buf;
61857
61857
  };
@@ -62725,8 +62725,8 @@ var require_dbcs_codec = __commonJS({
62725
62725
  this.defaultCharSingleByte = codec2.defCharSB;
62726
62726
  this.gb18030 = codec2.gb18030;
62727
62727
  }
62728
- DBCSEncoder.prototype.write = function(str) {
62729
- var newBuf = Buffer2.alloc(str.length * (this.gb18030 ? 4 : 3));
62728
+ DBCSEncoder.prototype.write = function(str2) {
62729
+ var newBuf = Buffer2.alloc(str2.length * (this.gb18030 ? 4 : 3));
62730
62730
  var leadSurrogate = this.leadSurrogate;
62731
62731
  var seqObj = this.seqObj;
62732
62732
  var nextChar = -1;
@@ -62734,8 +62734,8 @@ var require_dbcs_codec = __commonJS({
62734
62734
  var j = 0;
62735
62735
  while (true) {
62736
62736
  if (nextChar === -1) {
62737
- if (i2 == str.length) break;
62738
- var uCode = str.charCodeAt(i2++);
62737
+ if (i2 == str2.length) break;
62738
+ var uCode = str2.charCodeAt(i2++);
62739
62739
  } else {
62740
62740
  var uCode = nextChar;
62741
62741
  nextChar = -1;
@@ -64573,10 +64573,10 @@ var require_lib4 = __commonJS({
64573
64573
  module2.exports.encodings = null;
64574
64574
  module2.exports.defaultCharUnicode = "\uFFFD";
64575
64575
  module2.exports.defaultCharSingleByte = "?";
64576
- module2.exports.encode = function encode3(str, encoding, options) {
64577
- str = "" + (str || "");
64576
+ module2.exports.encode = function encode3(str2, encoding, options) {
64577
+ str2 = "" + (str2 || "");
64578
64578
  var encoder = module2.exports.getEncoder(encoding, options);
64579
- var res = encoder.write(str);
64579
+ var res = encoder.write(str2);
64580
64580
  var trail = encoder.end();
64581
64581
  return trail && trail.length > 0 ? Buffer2.concat([res, trail]) : res;
64582
64582
  };
@@ -65170,14 +65170,14 @@ var require_content_type = __commonJS({
65170
65170
  return header;
65171
65171
  }
65172
65172
  function qstring(val) {
65173
- var str = String(val);
65174
- if (TOKEN_REGEXP.test(str)) {
65175
- return str;
65173
+ var str2 = String(val);
65174
+ if (TOKEN_REGEXP.test(str2)) {
65175
+ return str2;
65176
65176
  }
65177
- if (str.length > 0 && !TEXT_REGEXP.test(str)) {
65177
+ if (str2.length > 0 && !TEXT_REGEXP.test(str2)) {
65178
65178
  throw new TypeError("invalid parameter value");
65179
65179
  }
65180
- return '"' + str.replace(QUOTE_REGEXP, "\\$1") + '"';
65180
+ return '"' + str2.replace(QUOTE_REGEXP, "\\$1") + '"';
65181
65181
  }
65182
65182
  function ContentType(type) {
65183
65183
  this.parameters = /* @__PURE__ */ Object.create(null);
@@ -74617,11 +74617,11 @@ var require_mime_types = __commonJS({
74617
74617
  }
74618
74618
  return false;
74619
74619
  }
74620
- function contentType(str) {
74621
- if (!str || typeof str !== "string") {
74620
+ function contentType(str2) {
74621
+ if (!str2 || typeof str2 !== "string") {
74622
74622
  return false;
74623
74623
  }
74624
- var mime = str.indexOf("/") === -1 ? exports2.lookup(str) : str;
74624
+ var mime = str2.indexOf("/") === -1 ? exports2.lookup(str2) : str2;
74625
74625
  if (!mime) {
74626
74626
  return false;
74627
74627
  }
@@ -75002,14 +75002,14 @@ var require_read = __commonJS({
75002
75002
  return;
75003
75003
  }
75004
75004
  }
75005
- var str = body;
75005
+ var str2 = body;
75006
75006
  try {
75007
75007
  debug("parse body");
75008
- str = typeof body !== "string" && encoding !== null ? iconv.decode(body, encoding) : body;
75009
- req.body = parse4(str, encoding);
75008
+ str2 = typeof body !== "string" && encoding !== null ? iconv.decode(body, encoding) : body;
75009
+ req.body = parse4(str2, encoding);
75010
75010
  } catch (err2) {
75011
75011
  next(createError(400, err2, {
75012
- body: str,
75012
+ body: str2,
75013
75013
  type: err2.type || "entity.parse.failed"
75014
75014
  }));
75015
75015
  return;
@@ -75109,11 +75109,11 @@ var require_json = __commonJS({
75109
75109
  read(req, res, next, parse4, debug, readOptions);
75110
75110
  };
75111
75111
  }
75112
- function createStrictSyntaxError(str, char) {
75113
- var index = str.indexOf(char);
75112
+ function createStrictSyntaxError(str2, char) {
75113
+ var index = str2.indexOf(char);
75114
75114
  var partial2 = "";
75115
75115
  if (index !== -1) {
75116
- partial2 = str.substring(0, index) + JSON_SYNTAX_CHAR.repeat(str.length - index);
75116
+ partial2 = str2.substring(0, index) + JSON_SYNTAX_CHAR.repeat(str2.length - index);
75117
75117
  }
75118
75118
  try {
75119
75119
  JSON.parse(partial2);
@@ -75121,14 +75121,14 @@ var require_json = __commonJS({
75121
75121
  } catch (e) {
75122
75122
  return normalizeJsonSyntaxError(e, {
75123
75123
  message: e.message.replace(JSON_SYNTAX_REGEXP, function(placeholder) {
75124
- return str.substring(index, index + placeholder.length);
75124
+ return str2.substring(index, index + placeholder.length);
75125
75125
  }),
75126
75126
  stack: e.stack
75127
75127
  });
75128
75128
  }
75129
75129
  }
75130
- function firstchar(str) {
75131
- var match = FIRST_CHAR_REGEXP.exec(str);
75130
+ function firstchar(str2) {
75131
+ var match = FIRST_CHAR_REGEXP.exec(str2);
75132
75132
  return match ? match[1] : void 0;
75133
75133
  }
75134
75134
  function normalizeJsonSyntaxError(error2, obj) {
@@ -75239,20 +75239,20 @@ var require_object_inspect = __commonJS({
75239
75239
  var gPO = (typeof Reflect === "function" ? Reflect.getPrototypeOf : Object.getPrototypeOf) || ([].__proto__ === Array.prototype ? function(O) {
75240
75240
  return O.__proto__;
75241
75241
  } : null);
75242
- function addNumericSeparator(num, str) {
75243
- if (num === Infinity || num === -Infinity || num !== num || num && num > -1e3 && num < 1e3 || $test.call(/e/, str)) {
75244
- return str;
75242
+ function addNumericSeparator(num, str2) {
75243
+ if (num === Infinity || num === -Infinity || num !== num || num && num > -1e3 && num < 1e3 || $test.call(/e/, str2)) {
75244
+ return str2;
75245
75245
  }
75246
75246
  var sepRegex = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g;
75247
75247
  if (typeof num === "number") {
75248
75248
  var int2 = num < 0 ? -$floor(-num) : $floor(num);
75249
75249
  if (int2 !== num) {
75250
75250
  var intStr = String(int2);
75251
- var dec = $slice.call(str, intStr.length + 1);
75251
+ var dec = $slice.call(str2, intStr.length + 1);
75252
75252
  return $replace.call(intStr, sepRegex, "$&_") + "." + $replace.call($replace.call(dec, /([0-9]{3})/g, "$&_"), /_$/, "");
75253
75253
  }
75254
75254
  }
75255
- return $replace.call(str, sepRegex, "$&_");
75255
+ return $replace.call(str2, sepRegex, "$&_");
75256
75256
  }
75257
75257
  var utilInspect = require_util_inspect();
75258
75258
  var inspectCustom = utilInspect.custom;
@@ -75302,8 +75302,8 @@ var require_object_inspect = __commonJS({
75302
75302
  if (obj === 0) {
75303
75303
  return Infinity / obj > 0 ? "0" : "-0";
75304
75304
  }
75305
- var str = String(obj);
75306
- return numericSeparator ? addNumericSeparator(obj, str) : str;
75305
+ var str2 = String(obj);
75306
+ return numericSeparator ? addNumericSeparator(obj, str2) : str2;
75307
75307
  }
75308
75308
  if (typeof obj === "bigint") {
75309
75309
  var bigIntStr = String(obj) + "n";
@@ -75623,15 +75623,15 @@ var require_object_inspect = __commonJS({
75623
75623
  }
75624
75624
  return typeof x.nodeName === "string" && typeof x.getAttribute === "function";
75625
75625
  }
75626
- function inspectString(str, opts) {
75627
- if (str.length > opts.maxStringLength) {
75628
- var remaining = str.length - opts.maxStringLength;
75626
+ function inspectString(str2, opts) {
75627
+ if (str2.length > opts.maxStringLength) {
75628
+ var remaining = str2.length - opts.maxStringLength;
75629
75629
  var trailer = "... " + remaining + " more character" + (remaining > 1 ? "s" : "");
75630
- return inspectString($slice.call(str, 0, opts.maxStringLength), opts) + trailer;
75630
+ return inspectString($slice.call(str2, 0, opts.maxStringLength), opts) + trailer;
75631
75631
  }
75632
75632
  var quoteRE = quoteREs[opts.quoteStyle || "single"];
75633
75633
  quoteRE.lastIndex = 0;
75634
- var s = $replace.call($replace.call(str, quoteRE, "\\$1"), /[\x00-\x1f]/g, lowbyte);
75634
+ var s = $replace.call($replace.call(str2, quoteRE, "\\$1"), /[\x00-\x1f]/g, lowbyte);
75635
75635
  return wrapQuotes(s, "single", opts);
75636
75636
  }
75637
75637
  function lowbyte(c) {
@@ -75648,8 +75648,8 @@ var require_object_inspect = __commonJS({
75648
75648
  }
75649
75649
  return "\\x" + (n < 16 ? "0" : "") + $toUpperCase.call(n.toString(16));
75650
75650
  }
75651
- function markBoxed(str) {
75652
- return "Object(" + str + ")";
75651
+ function markBoxed(str2) {
75652
+ return "Object(" + str2 + ")";
75653
75653
  }
75654
75654
  function weakCollectionOf(type) {
75655
75655
  return type + " { ? }";
@@ -76115,14 +76115,14 @@ var require_implementation = __commonJS({
76115
76115
  return arr;
76116
76116
  };
76117
76117
  var joiny = function(arr, joiner) {
76118
- var str = "";
76118
+ var str2 = "";
76119
76119
  for (var i = 0; i < arr.length; i += 1) {
76120
- str += arr[i];
76120
+ str2 += arr[i];
76121
76121
  if (i + 1 < arr.length) {
76122
- str += joiner;
76122
+ str2 += joiner;
76123
76123
  }
76124
76124
  }
76125
- return str;
76125
+ return str2;
76126
76126
  };
76127
76127
  module2.exports = function bind(that) {
76128
76128
  var target = this;
@@ -76957,8 +76957,8 @@ var require_utils7 = __commonJS({
76957
76957
  return acc;
76958
76958
  }, target);
76959
76959
  };
76960
- var decode3 = function(str, defaultDecoder, charset) {
76961
- var strWithoutPlus = str.replace(/\+/g, " ");
76960
+ var decode3 = function(str2, defaultDecoder, charset) {
76961
+ var strWithoutPlus = str2.replace(/\+/g, " ");
76962
76962
  if (charset === "iso-8859-1") {
76963
76963
  return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape);
76964
76964
  }
@@ -76969,15 +76969,15 @@ var require_utils7 = __commonJS({
76969
76969
  }
76970
76970
  };
76971
76971
  var limit = 1024;
76972
- var encode3 = function encode4(str, defaultEncoder, charset, kind, format) {
76973
- if (str.length === 0) {
76974
- return str;
76972
+ var encode3 = function encode4(str2, defaultEncoder, charset, kind, format) {
76973
+ if (str2.length === 0) {
76974
+ return str2;
76975
76975
  }
76976
- var string3 = str;
76977
- if (typeof str === "symbol") {
76978
- string3 = Symbol.prototype.toString.call(str);
76979
- } else if (typeof str !== "string") {
76980
- string3 = String(str);
76976
+ var string3 = str2;
76977
+ if (typeof str2 === "symbol") {
76978
+ string3 = Symbol.prototype.toString.call(str2);
76979
+ } else if (typeof str2 !== "string") {
76980
+ string3 = String(str2);
76981
76981
  }
76982
76982
  if (charset === "iso-8859-1") {
76983
76983
  return escape(string3).replace(/%u[0-9a-f]{4}/gi, function($0) {
@@ -77394,8 +77394,8 @@ var require_parse2 = __commonJS({
77394
77394
  strictNullHandling: false,
77395
77395
  throwOnLimitExceeded: false
77396
77396
  };
77397
- var interpretNumericEntities = function(str) {
77398
- return str.replace(/&#(\d+);/g, function($0, numberStr) {
77397
+ var interpretNumericEntities = function(str2) {
77398
+ return str2.replace(/&#(\d+);/g, function($0, numberStr) {
77399
77399
  return String.fromCharCode(parseInt(numberStr, 10));
77400
77400
  });
77401
77401
  };
@@ -77410,9 +77410,9 @@ var require_parse2 = __commonJS({
77410
77410
  };
77411
77411
  var isoSentinel = "utf8=%26%2310003%3B";
77412
77412
  var charsetSentinel = "utf8=%E2%9C%93";
77413
- var parseValues = function parseQueryStringValues(str, options) {
77413
+ var parseValues = function parseQueryStringValues(str2, options) {
77414
77414
  var obj = { __proto__: null };
77415
- var cleanStr = options.ignoreQueryPrefix ? str.replace(/^\?/, "") : str;
77415
+ var cleanStr = options.ignoreQueryPrefix ? str2.replace(/^\?/, "") : str2;
77416
77416
  cleanStr = cleanStr.replace(/%5B/gi, "[").replace(/%5D/gi, "]");
77417
77417
  var limit = options.parameterLimit === Infinity ? void 0 : options.parameterLimit;
77418
77418
  var parts = cleanStr.split(
@@ -77628,17 +77628,17 @@ var require_parse2 = __commonJS({
77628
77628
  throwOnLimitExceeded: typeof opts.throwOnLimitExceeded === "boolean" ? opts.throwOnLimitExceeded : false
77629
77629
  };
77630
77630
  };
77631
- module2.exports = function(str, opts) {
77631
+ module2.exports = function(str2, opts) {
77632
77632
  var options = normalizeParseOptions(opts);
77633
- if (str === "" || str === null || typeof str === "undefined") {
77633
+ if (str2 === "" || str2 === null || typeof str2 === "undefined") {
77634
77634
  return options.plainObjects ? { __proto__: null } : {};
77635
77635
  }
77636
- var tempObj = typeof str === "string" ? parseValues(str, options) : str;
77636
+ var tempObj = typeof str2 === "string" ? parseValues(str2, options) : str2;
77637
77637
  var obj = options.plainObjects ? { __proto__: null } : {};
77638
77638
  var keys = Object.keys(tempObj);
77639
77639
  for (var i = 0; i < keys.length; ++i) {
77640
77640
  var key = keys[i];
77641
- var newObj = parseKeys(key, tempObj[key], options, typeof str === "string");
77641
+ var newObj = parseKeys(key, tempObj[key], options, typeof str2 === "string");
77642
77642
  obj = utils.merge(obj, newObj, options);
77643
77643
  }
77644
77644
  if (options.allowSparse === true) {
@@ -77828,17 +77828,17 @@ var require_escape_html = __commonJS({
77828
77828
  var matchHtmlRegExp = /["'&<>]/;
77829
77829
  module2.exports = escapeHtml;
77830
77830
  function escapeHtml(string3) {
77831
- var str = "" + string3;
77832
- var match = matchHtmlRegExp.exec(str);
77831
+ var str2 = "" + string3;
77832
+ var match = matchHtmlRegExp.exec(str2);
77833
77833
  if (!match) {
77834
- return str;
77834
+ return str2;
77835
77835
  }
77836
77836
  var escape2;
77837
77837
  var html = "";
77838
77838
  var index = 0;
77839
77839
  var lastIndex = 0;
77840
- for (index = match.index; index < str.length; index++) {
77841
- switch (str.charCodeAt(index)) {
77840
+ for (index = match.index; index < str2.length; index++) {
77841
+ switch (str2.charCodeAt(index)) {
77842
77842
  case 34:
77843
77843
  escape2 = "&quot;";
77844
77844
  break;
@@ -77858,12 +77858,12 @@ var require_escape_html = __commonJS({
77858
77858
  continue;
77859
77859
  }
77860
77860
  if (lastIndex !== index) {
77861
- html += str.substring(lastIndex, index);
77861
+ html += str2.substring(lastIndex, index);
77862
77862
  }
77863
77863
  lastIndex = index + 1;
77864
77864
  html += escape2;
77865
77865
  }
77866
- return lastIndex !== index ? html + str.substring(lastIndex, index) : html;
77866
+ return lastIndex !== index ? html + str2.substring(lastIndex, index) : html;
77867
77867
  }
77868
77868
  }
77869
77869
  });
@@ -77903,20 +77903,20 @@ var require_parseurl = __commonJS({
77903
77903
  parsed._raw = url3;
77904
77904
  return req._parsedOriginalUrl = parsed;
77905
77905
  }
77906
- function fastparse(str) {
77907
- if (typeof str !== "string" || str.charCodeAt(0) !== 47) {
77908
- return parse4(str);
77906
+ function fastparse(str2) {
77907
+ if (typeof str2 !== "string" || str2.charCodeAt(0) !== 47) {
77908
+ return parse4(str2);
77909
77909
  }
77910
- var pathname = str;
77910
+ var pathname = str2;
77911
77911
  var query = null;
77912
77912
  var search = null;
77913
- for (var i = 1; i < str.length; i++) {
77914
- switch (str.charCodeAt(i)) {
77913
+ for (var i = 1; i < str2.length; i++) {
77914
+ switch (str2.charCodeAt(i)) {
77915
77915
  case 63:
77916
77916
  if (search === null) {
77917
- pathname = str.substring(0, i);
77918
- query = str.substring(i + 1);
77919
- search = str.substring(i);
77917
+ pathname = str2.substring(0, i);
77918
+ query = str2.substring(i + 1);
77919
+ search = str2.substring(i);
77920
77920
  }
77921
77921
  break;
77922
77922
  case 9:
@@ -77933,12 +77933,12 @@ var require_parseurl = __commonJS({
77933
77933
  /* # */
77934
77934
  case 160:
77935
77935
  case 65279:
77936
- return parse4(str);
77936
+ return parse4(str2);
77937
77937
  }
77938
77938
  }
77939
77939
  var url3 = Url !== void 0 ? new Url() : {};
77940
- url3.path = str;
77941
- url3.href = str;
77940
+ url3.path = str2;
77941
+ url3.href = str2;
77942
77942
  url3.pathname = pathname;
77943
77943
  if (search !== null) {
77944
77944
  url3.query = query;
@@ -78951,11 +78951,11 @@ var require_proxy_addr = __commonJS({
78951
78951
  }
78952
78952
  function parseipNotation(note) {
78953
78953
  var pos = note.lastIndexOf("/");
78954
- var str = pos !== -1 ? note.substring(0, pos) : note;
78955
- if (!isip(str)) {
78956
- throw new TypeError("invalid IP address: " + str);
78954
+ var str2 = pos !== -1 ? note.substring(0, pos) : note;
78955
+ if (!isip(str2)) {
78956
+ throw new TypeError("invalid IP address: " + str2);
78957
78957
  }
78958
- var ip = parseip(str);
78958
+ var ip = parseip(str2);
78959
78959
  if (pos === -1 && ip.kind() === "ipv6" && ip.isIPv4MappedAddress()) {
78960
78960
  ip = ip.toIPv4Address();
78961
78961
  }
@@ -79064,22 +79064,22 @@ var require_utils8 = __commonJS({
79064
79064
  exports2.normalizeTypes = function(types2) {
79065
79065
  return types2.map(exports2.normalizeType);
79066
79066
  };
79067
- function acceptParams(str) {
79068
- var length = str.length;
79069
- var colonIndex = str.indexOf(";");
79067
+ function acceptParams(str2) {
79068
+ var length = str2.length;
79069
+ var colonIndex = str2.indexOf(";");
79070
79070
  var index = colonIndex === -1 ? length : colonIndex;
79071
- var ret = { value: str.slice(0, index).trim(), quality: 1, params: {} };
79071
+ var ret = { value: str2.slice(0, index).trim(), quality: 1, params: {} };
79072
79072
  while (index < length) {
79073
- var splitIndex = str.indexOf("=", index);
79073
+ var splitIndex = str2.indexOf("=", index);
79074
79074
  if (splitIndex === -1) break;
79075
- var colonIndex = str.indexOf(";", index);
79075
+ var colonIndex = str2.indexOf(";", index);
79076
79076
  var endIndex = colonIndex === -1 ? length : colonIndex;
79077
79077
  if (splitIndex > endIndex) {
79078
- index = str.lastIndexOf(";", splitIndex - 1) + 1;
79078
+ index = str2.lastIndexOf(";", splitIndex - 1) + 1;
79079
79079
  continue;
79080
79080
  }
79081
- var key = str.slice(index, splitIndex).trim();
79082
- var value = str.slice(splitIndex + 1, endIndex).trim();
79081
+ var key = str2.slice(index, splitIndex).trim();
79082
+ var value = str2.slice(splitIndex + 1, endIndex).trim();
79083
79083
  if (key === "q") {
79084
79084
  ret.quality = parseFloat(value);
79085
79085
  } else {
@@ -79162,8 +79162,8 @@ var require_utils8 = __commonJS({
79162
79162
  return etag(buf, options);
79163
79163
  };
79164
79164
  }
79165
- function parseExtendedQueryString(str) {
79166
- return qs.parse(str, {
79165
+ function parseExtendedQueryString(str2) {
79166
+ return qs.parse(str2, {
79167
79167
  allowPrototypes: true
79168
79168
  });
79169
79169
  }
@@ -79283,11 +79283,11 @@ var require_dist3 = __commonJS({
79283
79283
  "?": "?",
79284
79284
  "!": "!"
79285
79285
  };
79286
- function escapeText(str) {
79287
- return str.replace(/[{}()\[\]+?!:*\\]/g, "\\$&");
79286
+ function escapeText(str2) {
79287
+ return str2.replace(/[{}()\[\]+?!:*\\]/g, "\\$&");
79288
79288
  }
79289
- function escape2(str) {
79290
- return str.replace(/[.+*?^${}()[\]|/\\]/g, "\\$&");
79289
+ function escape2(str2) {
79290
+ return str2.replace(/[.+*?^${}()[\]|/\\]/g, "\\$&");
79291
79291
  }
79292
79292
  var TokenData = class {
79293
79293
  constructor(tokens, originalPath) {
@@ -79307,9 +79307,9 @@ var require_dist3 = __commonJS({
79307
79307
  }
79308
79308
  };
79309
79309
  exports2.PathError = PathError;
79310
- function parse4(str, options = {}) {
79310
+ function parse4(str2, options = {}) {
79311
79311
  const { encodePath = NOOP_VALUE } = options;
79312
- const chars = [...str];
79312
+ const chars = [...str2];
79313
79313
  const tokens = [];
79314
79314
  let index = 0;
79315
79315
  let pos = 0;
@@ -79332,11 +79332,11 @@ var require_dist3 = __commonJS({
79332
79332
  value += chars[index];
79333
79333
  }
79334
79334
  if (quoteStart) {
79335
- throw new PathError(`Unterminated quote at index ${quoteStart}`, str);
79335
+ throw new PathError(`Unterminated quote at index ${quoteStart}`, str2);
79336
79336
  }
79337
79337
  }
79338
79338
  if (!value) {
79339
- throw new PathError(`Missing parameter name at index ${index}`, str);
79339
+ throw new PathError(`Missing parameter name at index ${index}`, str2);
79340
79340
  }
79341
79341
  return value;
79342
79342
  }
@@ -79389,11 +79389,11 @@ var require_dist3 = __commonJS({
79389
79389
  });
79390
79390
  continue;
79391
79391
  }
79392
- throw new PathError(`Unexpected ${token2.type} at index ${token2.index}, expected ${endType}`, str);
79392
+ throw new PathError(`Unexpected ${token2.type} at index ${token2.index}, expected ${endType}`, str2);
79393
79393
  }
79394
79394
  return output;
79395
79395
  }
79396
- return new TokenData(consumeUntil("end"), str);
79396
+ return new TokenData(consumeUntil("end"), str2);
79397
79397
  }
79398
79398
  function compile(path2, options = {}) {
79399
79399
  const { encode: encode3 = encodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;
@@ -80557,8 +80557,8 @@ var require_charset = __commonJS({
80557
80557
  accepts.length = j;
80558
80558
  return accepts;
80559
80559
  }
80560
- function parseCharset(str, i) {
80561
- var match = simpleCharsetRegExp.exec(str);
80560
+ function parseCharset(str2, i) {
80561
+ var match = simpleCharsetRegExp.exec(str2);
80562
80562
  if (!match) return null;
80563
80563
  var charset = match[1];
80564
80564
  var q = 1;
@@ -80655,8 +80655,8 @@ var require_encoding = __commonJS({
80655
80655
  accepts.length = j;
80656
80656
  return accepts;
80657
80657
  }
80658
- function parseEncoding(str, i) {
80659
- var match = simpleEncodingRegExp.exec(str);
80658
+ function parseEncoding(str2, i) {
80659
+ var match = simpleEncodingRegExp.exec(str2);
80660
80660
  if (!match) return null;
80661
80661
  var encoding = match[1];
80662
80662
  var q = 1;
@@ -80757,8 +80757,8 @@ var require_language = __commonJS({
80757
80757
  accepts.length = j;
80758
80758
  return accepts;
80759
80759
  }
80760
- function parseLanguage(str, i) {
80761
- var match = simpleLanguageRegExp.exec(str);
80760
+ function parseLanguage(str2, i) {
80761
+ var match = simpleLanguageRegExp.exec(str2);
80762
80762
  if (!match) return null;
80763
80763
  var prefix = match[1];
80764
80764
  var suffix = match[2];
@@ -80852,8 +80852,8 @@ var require_mediaType = __commonJS({
80852
80852
  accepts.length = j;
80853
80853
  return accepts;
80854
80854
  }
80855
- function parseMediaType(str, i) {
80856
- var match = simpleMediaTypeRegExp.exec(str);
80855
+ function parseMediaType(str2, i) {
80856
+ var match = simpleMediaTypeRegExp.exec(str2);
80857
80857
  if (!match) return null;
80858
80858
  var params = /* @__PURE__ */ Object.create(null);
80859
80859
  var q = 1;
@@ -80954,15 +80954,15 @@ var require_mediaType = __commonJS({
80954
80954
  }
80955
80955
  return count4;
80956
80956
  }
80957
- function splitKeyValuePair(str) {
80958
- var index = str.indexOf("=");
80957
+ function splitKeyValuePair(str2) {
80958
+ var index = str2.indexOf("=");
80959
80959
  var key;
80960
80960
  var val;
80961
80961
  if (index === -1) {
80962
- key = str;
80962
+ key = str2;
80963
80963
  } else {
80964
- key = str.slice(0, index);
80965
- val = str.slice(index + 1);
80964
+ key = str2.slice(0, index);
80965
+ val = str2.slice(index + 1);
80966
80966
  }
80967
80967
  return [key, val];
80968
80968
  }
@@ -80978,8 +80978,8 @@ var require_mediaType = __commonJS({
80978
80978
  accepts.length = j + 1;
80979
80979
  return accepts;
80980
80980
  }
80981
- function splitParameters(str) {
80982
- var parameters = str.split(";");
80981
+ function splitParameters(str2) {
80982
+ var parameters = str2.split(";");
80983
80983
  for (var i = 1, j = 0; i < parameters.length; i++) {
80984
80984
  if (quoteCount(parameters[j]) % 2 == 0) {
80985
80985
  parameters[++j] = parameters[i];
@@ -81179,19 +81179,19 @@ var require_fresh = __commonJS({
81179
81179
  var timestamp = date4 && Date.parse(date4);
81180
81180
  return typeof timestamp === "number" ? timestamp : NaN;
81181
81181
  }
81182
- function parseTokenList(str) {
81182
+ function parseTokenList(str2) {
81183
81183
  var end = 0;
81184
81184
  var list2 = [];
81185
81185
  var start = 0;
81186
- for (var i = 0, len = str.length; i < len; i++) {
81187
- switch (str.charCodeAt(i)) {
81186
+ for (var i = 0, len = str2.length; i < len; i++) {
81187
+ switch (str2.charCodeAt(i)) {
81188
81188
  case 32:
81189
81189
  if (start === end) {
81190
81190
  start = end = i + 1;
81191
81191
  }
81192
81192
  break;
81193
81193
  case 44:
81194
- list2.push(str.substring(start, end));
81194
+ list2.push(str2.substring(start, end));
81195
81195
  start = end = i + 1;
81196
81196
  break;
81197
81197
  default:
@@ -81199,7 +81199,7 @@ var require_fresh = __commonJS({
81199
81199
  break;
81200
81200
  }
81201
81201
  }
81202
- list2.push(str.substring(start, end));
81202
+ list2.push(str2.substring(start, end));
81203
81203
  return list2;
81204
81204
  }
81205
81205
  }
@@ -81210,17 +81210,17 @@ var require_range_parser = __commonJS({
81210
81210
  "../../node_modules/range-parser/index.js"(exports2, module2) {
81211
81211
  "use strict";
81212
81212
  module2.exports = rangeParser;
81213
- function rangeParser(size, str, options) {
81214
- if (typeof str !== "string") {
81213
+ function rangeParser(size, str2, options) {
81214
+ if (typeof str2 !== "string") {
81215
81215
  throw new TypeError("argument str must be a string");
81216
81216
  }
81217
- var index = str.indexOf("=");
81217
+ var index = str2.indexOf("=");
81218
81218
  if (index === -1) {
81219
81219
  return -2;
81220
81220
  }
81221
- var arr = str.slice(index + 1).split(",");
81221
+ var arr = str2.slice(index + 1).split(",");
81222
81222
  var ranges = [];
81223
- ranges.type = str.slice(0, index);
81223
+ ranges.type = str2.slice(0, index);
81224
81224
  for (var i = 0; i < arr.length; i++) {
81225
81225
  var range = arr[i].split("-");
81226
81226
  var start = parseInt(range[0], 10);
@@ -81505,8 +81505,8 @@ var require_content_disposition = __commonJS({
81505
81505
  }
81506
81506
  return string3;
81507
81507
  }
81508
- function decodefield(str) {
81509
- var match = EXT_VALUE_REGEXP.exec(str);
81508
+ function decodefield(str2) {
81509
+ var match = EXT_VALUE_REGEXP.exec(str2);
81510
81510
  if (!match) {
81511
81511
  throw new TypeError("invalid extended field value");
81512
81512
  }
@@ -81575,19 +81575,19 @@ var require_content_disposition = __commonJS({
81575
81575
  }
81576
81576
  return new ContentDisposition(type, params);
81577
81577
  }
81578
- function pdecode(str, hex3) {
81578
+ function pdecode(str2, hex3) {
81579
81579
  return String.fromCharCode(parseInt(hex3, 16));
81580
81580
  }
81581
81581
  function pencode(char) {
81582
81582
  return "%" + String(char).charCodeAt(0).toString(16).toUpperCase();
81583
81583
  }
81584
81584
  function qstring(val) {
81585
- var str = String(val);
81586
- return '"' + str.replace(QUOTE_REGEXP, "\\$1") + '"';
81585
+ var str2 = String(val);
81586
+ return '"' + str2.replace(QUOTE_REGEXP, "\\$1") + '"';
81587
81587
  }
81588
81588
  function ustring(val) {
81589
- var str = String(val);
81590
- var encoded = encodeURIComponent(str).replace(ENCODE_URL_ATTR_CHAR_REGEXP, pencode);
81589
+ var str2 = String(val);
81590
+ var encoded = encodeURIComponent(str2).replace(ENCODE_URL_ATTR_CHAR_REGEXP, pencode);
81591
81591
  return "UTF-8''" + encoded;
81592
81592
  }
81593
81593
  function ContentDisposition(type, parameters) {
@@ -81627,54 +81627,54 @@ var require_cookie = __commonJS({
81627
81627
  var cookieValueRegExp = /^("?)[\u0021\u0023-\u002B\u002D-\u003A\u003C-\u005B\u005D-\u007E]*\1$/;
81628
81628
  var domainValueRegExp = /^([.]?[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)([.][a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)*$/i;
81629
81629
  var pathValueRegExp = /^[\u0020-\u003A\u003D-\u007E]*$/;
81630
- function parse4(str, opt) {
81631
- if (typeof str !== "string") {
81630
+ function parse4(str2, opt) {
81631
+ if (typeof str2 !== "string") {
81632
81632
  throw new TypeError("argument str must be a string");
81633
81633
  }
81634
81634
  var obj = {};
81635
- var len = str.length;
81635
+ var len = str2.length;
81636
81636
  if (len < 2) return obj;
81637
81637
  var dec = opt && opt.decode || decode3;
81638
81638
  var index = 0;
81639
81639
  var eqIdx = 0;
81640
81640
  var endIdx = 0;
81641
81641
  do {
81642
- eqIdx = str.indexOf("=", index);
81642
+ eqIdx = str2.indexOf("=", index);
81643
81643
  if (eqIdx === -1) break;
81644
- endIdx = str.indexOf(";", index);
81644
+ endIdx = str2.indexOf(";", index);
81645
81645
  if (endIdx === -1) {
81646
81646
  endIdx = len;
81647
81647
  } else if (eqIdx > endIdx) {
81648
- index = str.lastIndexOf(";", eqIdx - 1) + 1;
81648
+ index = str2.lastIndexOf(";", eqIdx - 1) + 1;
81649
81649
  continue;
81650
81650
  }
81651
- var keyStartIdx = startIndex(str, index, eqIdx);
81652
- var keyEndIdx = endIndex(str, eqIdx, keyStartIdx);
81653
- var key = str.slice(keyStartIdx, keyEndIdx);
81651
+ var keyStartIdx = startIndex(str2, index, eqIdx);
81652
+ var keyEndIdx = endIndex(str2, eqIdx, keyStartIdx);
81653
+ var key = str2.slice(keyStartIdx, keyEndIdx);
81654
81654
  if (!__hasOwnProperty.call(obj, key)) {
81655
- var valStartIdx = startIndex(str, eqIdx + 1, endIdx);
81656
- var valEndIdx = endIndex(str, endIdx, valStartIdx);
81657
- if (str.charCodeAt(valStartIdx) === 34 && str.charCodeAt(valEndIdx - 1) === 34) {
81655
+ var valStartIdx = startIndex(str2, eqIdx + 1, endIdx);
81656
+ var valEndIdx = endIndex(str2, endIdx, valStartIdx);
81657
+ if (str2.charCodeAt(valStartIdx) === 34 && str2.charCodeAt(valEndIdx - 1) === 34) {
81658
81658
  valStartIdx++;
81659
81659
  valEndIdx--;
81660
81660
  }
81661
- var val = str.slice(valStartIdx, valEndIdx);
81661
+ var val = str2.slice(valStartIdx, valEndIdx);
81662
81662
  obj[key] = tryDecode(val, dec);
81663
81663
  }
81664
81664
  index = endIdx + 1;
81665
81665
  } while (index < len);
81666
81666
  return obj;
81667
81667
  }
81668
- function startIndex(str, index, max2) {
81668
+ function startIndex(str2, index, max2) {
81669
81669
  do {
81670
- var code = str.charCodeAt(index);
81670
+ var code = str2.charCodeAt(index);
81671
81671
  if (code !== 32 && code !== 9) return index;
81672
81672
  } while (++index < max2);
81673
81673
  return max2;
81674
81674
  }
81675
- function endIndex(str, index, min) {
81675
+ function endIndex(str2, index, min) {
81676
81676
  while (index > min) {
81677
- var code = str.charCodeAt(--index);
81677
+ var code = str2.charCodeAt(--index);
81678
81678
  if (code !== 32 && code !== 9) return index + 1;
81679
81679
  }
81680
81680
  return min;
@@ -81691,54 +81691,54 @@ var require_cookie = __commonJS({
81691
81691
  if (!cookieValueRegExp.test(value)) {
81692
81692
  throw new TypeError("argument val is invalid");
81693
81693
  }
81694
- var str = name + "=" + value;
81695
- if (!opt) return str;
81694
+ var str2 = name + "=" + value;
81695
+ if (!opt) return str2;
81696
81696
  if (null != opt.maxAge) {
81697
81697
  var maxAge = Math.floor(opt.maxAge);
81698
81698
  if (!isFinite(maxAge)) {
81699
81699
  throw new TypeError("option maxAge is invalid");
81700
81700
  }
81701
- str += "; Max-Age=" + maxAge;
81701
+ str2 += "; Max-Age=" + maxAge;
81702
81702
  }
81703
81703
  if (opt.domain) {
81704
81704
  if (!domainValueRegExp.test(opt.domain)) {
81705
81705
  throw new TypeError("option domain is invalid");
81706
81706
  }
81707
- str += "; Domain=" + opt.domain;
81707
+ str2 += "; Domain=" + opt.domain;
81708
81708
  }
81709
81709
  if (opt.path) {
81710
81710
  if (!pathValueRegExp.test(opt.path)) {
81711
81711
  throw new TypeError("option path is invalid");
81712
81712
  }
81713
- str += "; Path=" + opt.path;
81713
+ str2 += "; Path=" + opt.path;
81714
81714
  }
81715
81715
  if (opt.expires) {
81716
81716
  var expires = opt.expires;
81717
81717
  if (!isDate(expires) || isNaN(expires.valueOf())) {
81718
81718
  throw new TypeError("option expires is invalid");
81719
81719
  }
81720
- str += "; Expires=" + expires.toUTCString();
81720
+ str2 += "; Expires=" + expires.toUTCString();
81721
81721
  }
81722
81722
  if (opt.httpOnly) {
81723
- str += "; HttpOnly";
81723
+ str2 += "; HttpOnly";
81724
81724
  }
81725
81725
  if (opt.secure) {
81726
- str += "; Secure";
81726
+ str2 += "; Secure";
81727
81727
  }
81728
81728
  if (opt.partitioned) {
81729
- str += "; Partitioned";
81729
+ str2 += "; Partitioned";
81730
81730
  }
81731
81731
  if (opt.priority) {
81732
81732
  var priority = typeof opt.priority === "string" ? opt.priority.toLowerCase() : opt.priority;
81733
81733
  switch (priority) {
81734
81734
  case "low":
81735
- str += "; Priority=Low";
81735
+ str2 += "; Priority=Low";
81736
81736
  break;
81737
81737
  case "medium":
81738
- str += "; Priority=Medium";
81738
+ str2 += "; Priority=Medium";
81739
81739
  break;
81740
81740
  case "high":
81741
- str += "; Priority=High";
81741
+ str2 += "; Priority=High";
81742
81742
  break;
81743
81743
  default:
81744
81744
  throw new TypeError("option priority is invalid");
@@ -81748,34 +81748,34 @@ var require_cookie = __commonJS({
81748
81748
  var sameSite = typeof opt.sameSite === "string" ? opt.sameSite.toLowerCase() : opt.sameSite;
81749
81749
  switch (sameSite) {
81750
81750
  case true:
81751
- str += "; SameSite=Strict";
81751
+ str2 += "; SameSite=Strict";
81752
81752
  break;
81753
81753
  case "lax":
81754
- str += "; SameSite=Lax";
81754
+ str2 += "; SameSite=Lax";
81755
81755
  break;
81756
81756
  case "strict":
81757
- str += "; SameSite=Strict";
81757
+ str2 += "; SameSite=Strict";
81758
81758
  break;
81759
81759
  case "none":
81760
- str += "; SameSite=None";
81760
+ str2 += "; SameSite=None";
81761
81761
  break;
81762
81762
  default:
81763
81763
  throw new TypeError("option sameSite is invalid");
81764
81764
  }
81765
81765
  }
81766
- return str;
81766
+ return str2;
81767
81767
  }
81768
- function decode3(str) {
81769
- return str.indexOf("%") !== -1 ? decodeURIComponent(str) : str;
81768
+ function decode3(str2) {
81769
+ return str2.indexOf("%") !== -1 ? decodeURIComponent(str2) : str2;
81770
81770
  }
81771
81771
  function isDate(val) {
81772
81772
  return __toString.call(val) === "[object Date]";
81773
81773
  }
81774
- function tryDecode(str, decode4) {
81774
+ function tryDecode(str2, decode4) {
81775
81775
  try {
81776
- return decode4(str);
81776
+ return decode4(str2);
81777
81777
  } catch (e) {
81778
- return str;
81778
+ return str2;
81779
81779
  }
81780
81780
  }
81781
81781
  }
@@ -82174,13 +82174,13 @@ var require_send = __commonJS({
82174
82174
  res.removeHeader(header);
82175
82175
  }
82176
82176
  }
82177
- function collapseLeadingSlashes(str) {
82178
- for (var i = 0; i < str.length; i++) {
82179
- if (str[i] !== "/") {
82177
+ function collapseLeadingSlashes(str2) {
82178
+ for (var i = 0; i < str2.length; i++) {
82179
+ if (str2[i] !== "/") {
82180
82180
  break;
82181
82181
  }
82182
82182
  }
82183
- return i > 1 ? "/" + str.substr(i) : str;
82183
+ return i > 1 ? "/" + str2.substr(i) : str2;
82184
82184
  }
82185
82185
  function containsDotFile(parts) {
82186
82186
  for (var i = 0; i < parts.length; i++) {
@@ -82227,12 +82227,12 @@ var require_send = __commonJS({
82227
82227
  var timestamp = date4 && Date.parse(date4);
82228
82228
  return typeof timestamp === "number" ? timestamp : NaN;
82229
82229
  }
82230
- function parseTokenList(str) {
82230
+ function parseTokenList(str2) {
82231
82231
  var end = 0;
82232
82232
  var list2 = [];
82233
82233
  var start = 0;
82234
- for (var i = 0, len = str.length; i < len; i++) {
82235
- switch (str.charCodeAt(i)) {
82234
+ for (var i = 0, len = str2.length; i < len; i++) {
82235
+ switch (str2.charCodeAt(i)) {
82236
82236
  case 32:
82237
82237
  if (start === end) {
82238
82238
  start = end = i + 1;
@@ -82240,7 +82240,7 @@ var require_send = __commonJS({
82240
82240
  break;
82241
82241
  case 44:
82242
82242
  if (start !== end) {
82243
- list2.push(str.substring(start, end));
82243
+ list2.push(str2.substring(start, end));
82244
82244
  }
82245
82245
  start = end = i + 1;
82246
82246
  break;
@@ -82250,7 +82250,7 @@ var require_send = __commonJS({
82250
82250
  }
82251
82251
  }
82252
82252
  if (start !== end) {
82253
- list2.push(str.substring(start, end));
82253
+ list2.push(str2.substring(start, end));
82254
82254
  }
82255
82255
  return list2;
82256
82256
  }
@@ -82714,9 +82714,9 @@ var require_response = __commonJS({
82714
82714
  opts = {};
82715
82715
  }
82716
82716
  opts._locals = self.locals;
82717
- done = done || function(err2, str) {
82717
+ done = done || function(err2, str2) {
82718
82718
  if (err2) return req.next(err2);
82719
- self.send(str);
82719
+ self.send(str2);
82720
82720
  };
82721
82721
  app.render(view, opts, done);
82722
82722
  };
@@ -82872,13 +82872,13 @@ var require_serve_static = __commonJS({
82872
82872
  stream.pipe(res);
82873
82873
  };
82874
82874
  }
82875
- function collapseLeadingSlashes(str) {
82876
- for (var i = 0; i < str.length; i++) {
82877
- if (str.charCodeAt(i) !== 47) {
82875
+ function collapseLeadingSlashes(str2) {
82876
+ for (var i = 0; i < str2.length; i++) {
82877
+ if (str2.charCodeAt(i) !== 47) {
82878
82878
  break;
82879
82879
  }
82880
82880
  }
82881
- return i > 1 ? "/" + str.substr(i) : str;
82881
+ return i > 1 ? "/" + str2.substr(i) : str2;
82882
82882
  }
82883
82883
  function createHtmlDocument(title, body) {
82884
82884
  return '<!DOCTYPE html>\n<html lang="en">\n<head>\n<meta charset="utf-8">\n<title>' + title + "</title>\n</head>\n<body>\n<pre>" + body + "</pre>\n</body>\n</html>\n";
@@ -87923,6 +87923,46 @@ var init_replay_relevance = __esm({
87923
87923
  }
87924
87924
  });
87925
87925
 
87926
+ // src/commands/replay-codex.ts
87927
+ function codexConfigOf(mcpJson) {
87928
+ let servers = {};
87929
+ try {
87930
+ const parsed = JSON.parse(mcpJson);
87931
+ if (parsed.mcpServers && typeof parsed.mcpServers === "object" && !Array.isArray(parsed.mcpServers))
87932
+ servers = parsed.mcpServers;
87933
+ } catch {
87934
+ servers = {};
87935
+ }
87936
+ const blocks = [];
87937
+ for (const [name, raw] of Object.entries(servers)) {
87938
+ if (!raw || typeof raw !== "object") continue;
87939
+ const s = raw;
87940
+ const lines = [`[mcp_servers.${str(name)}]`];
87941
+ if (typeof s.url === "string") {
87942
+ lines.push(`url = ${str(s.url)}`);
87943
+ if (s.headers && Object.keys(s.headers).length)
87944
+ lines.push(`http_headers = ${inlineTable(s.headers)}`);
87945
+ } else if (typeof s.command === "string") {
87946
+ lines.push(`command = ${str(s.command)}`);
87947
+ if (s.args?.length)
87948
+ lines.push(`args = [${s.args.map((a) => str(String(a))).join(", ")}]`);
87949
+ if (s.env && Object.keys(s.env).length)
87950
+ lines.push(`env = ${inlineTable(s.env)}`);
87951
+ } else continue;
87952
+ blocks.push(lines.join("\n"));
87953
+ }
87954
+ return blocks.length ? `${blocks.join("\n\n")}
87955
+ ` : "";
87956
+ }
87957
+ var str, inlineTable;
87958
+ var init_replay_codex = __esm({
87959
+ "src/commands/replay-codex.ts"() {
87960
+ "use strict";
87961
+ str = (v) => JSON.stringify(v);
87962
+ inlineTable = (o) => `{ ${Object.entries(o).map(([k, v]) => `${str(k)} = ${str(v)}`).join(", ")} }`;
87963
+ }
87964
+ });
87965
+
87926
87966
  // src/commands/replay-interface.ts
87927
87967
  function importsOf(source) {
87928
87968
  const text = stripComments(source);
@@ -88454,7 +88494,14 @@ async function runStoredReplays(options, deps) {
88454
88494
  `Shard ${options.shard.index}/${options.shard.count}: ${mine.length} of ${set2.tasks.length} task(s).`
88455
88495
  );
88456
88496
  const { states } = await runCalibration(
88457
- calibrateTaskOptions(options, { setupCmd, testCmd }),
88497
+ // With the context gate, --limit caps the tasks replayed (found ones),
88498
+ // not the ones calibrated: calibrating only the first n left the rest
88499
+ // "not valid" and the gate often found none among those n. Calibration
88500
+ // runs tests only, no model. Without the gate, the first n as before.
88501
+ calibrateTaskOptions(
88502
+ { ...options, limit: options.anyContext ? options.limit : null },
88503
+ { setupCmd, testCmd }
88504
+ ),
88458
88505
  { ...deps, report: deps.reportCalibration },
88459
88506
  { ...set2, tasks: mine }
88460
88507
  );
@@ -88606,21 +88653,32 @@ async function runStoredReplays(options, deps) {
88606
88653
  }
88607
88654
  const armTools = session && deps.listTools ? haansiTools ??= await deps.listTools(session).catch(() => []) : [];
88608
88655
  const configPath = `${deps.workDir()}/${task.taskId}-${arm}.mcp.json`;
88609
- deps.writeFile(configPath, mcpConfig(arm, session));
88610
- const r = await replayArm(
88611
- deps,
88612
- { ...options, setupCmd, testCmd },
88613
- asTask,
88614
- arm,
88615
- (feedback) => cardPrompt(task, feedback, arm, armTools),
88616
- async (dir) => {
88617
- changed = await changedFiles(deps, dir, task.baseSha);
88618
- agentDiff = await agentDiffOf(deps, dir, task.baseSha);
88619
- if (arm === "haansi") change = judgeChange(agentDiff);
88620
- },
88621
- { HAANSI_REPLAY_MCP_CONFIG: configPath }
88622
- );
88623
- deps.removeFile(configPath);
88656
+ const config6 = mcpConfig(arm, session);
88657
+ deps.writeFile(configPath, config6);
88658
+ const codexHome2 = `${deps.workDir()}/${task.taskId}-${arm}.codex`;
88659
+ deps.writeFile(`${codexHome2}/config.toml`, codexConfigOf(config6));
88660
+ let r;
88661
+ try {
88662
+ r = await replayArm(
88663
+ deps,
88664
+ { ...options, setupCmd, testCmd },
88665
+ asTask,
88666
+ arm,
88667
+ (feedback) => cardPrompt(task, feedback, arm, armTools),
88668
+ async (dir) => {
88669
+ changed = await changedFiles(deps, dir, task.baseSha);
88670
+ agentDiff = await agentDiffOf(deps, dir, task.baseSha);
88671
+ if (arm === "haansi") change = judgeChange(agentDiff);
88672
+ },
88673
+ {
88674
+ HAANSI_REPLAY_MCP_CONFIG: configPath,
88675
+ HAANSI_REPLAY_CODEX_HOME: codexHome2
88676
+ }
88677
+ );
88678
+ } finally {
88679
+ deps.removeFile(configPath);
88680
+ deps.removeDir(codexHome2);
88681
+ }
88624
88682
  let haansi = null;
88625
88683
  if (session) {
88626
88684
  const { calls } = await deps.getCalls(session.sessionId);
@@ -88768,6 +88826,7 @@ var init_replay_tasks = __esm({
88768
88826
  init_replay_judge();
88769
88827
  init_replay();
88770
88828
  init_replay_scale();
88829
+ init_replay_codex();
88771
88830
  init_replay_interface();
88772
88831
  init_replay_context();
88773
88832
  FEEDBACK_HEADER = "Your previous attempt did not pass the tests. Their output ends with:";
@@ -89040,7 +89099,7 @@ async function replayArm(deps, options, task, arm, promptOf, inspect, agentEnv =
89040
89099
  const down = haansiServersDown(agent.output);
89041
89100
  if (down === null)
89042
89101
  deps.log(
89043
- `\u2026 ${label}: the agent did not report its MCP servers (use --output-format stream-json --verbose to check them)`
89102
+ `\u2026 ${label}: the agent did not report its MCP servers (Claude Code reports them with --output-format stream-json --verbose)`
89044
89103
  );
89045
89104
  else if (down.length)
89046
89105
  throw new Error(