openai/codex-action
Publicmirrored from https://github.com/openai/codex-actionAvailable
dist/main.js
10927lines · modecode
| 1 | "use strict"; |
| 2 | var __create = Object.create; |
| 3 | var __defProp = Object.defineProperty; |
| 4 | var __getOwnPropDesc = Object.getOwnPropertyDescriptor; |
| 5 | var __getOwnPropNames = Object.getOwnPropertyNames; |
| 6 | var __getProtoOf = Object.getPrototypeOf; |
| 7 | var __hasOwnProp = Object.prototype.hasOwnProperty; |
| 8 | var __commonJS = (cb, mod) => function __require() { |
| 9 | return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; |
| 10 | }; |
| 11 | var __export = (target, all) => { |
| 12 | for (var name in all) |
| 13 | __defProp(target, name, { get: all[name], enumerable: true }); |
| 14 | }; |
| 15 | var __copyProps = (to, from, except, desc) => { |
| 16 | if (from && typeof from === "object" || typeof from === "function") { |
| 17 | for (let key of __getOwnPropNames(from)) |
| 18 | if (!__hasOwnProp.call(to, key) && key !== except) |
| 19 | __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); |
| 20 | } |
| 21 | return to; |
| 22 | }; |
| 23 | var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( |
| 24 | // If the importer is in node compatibility mode or this is not an ESM |
| 25 | // file that has been converted to a CommonJS file using a Babel- |
| 26 | // compatible transform (i.e. "__esModule" has not been set), then set |
| 27 | // "default" to the CommonJS "module.exports" for node compatibility. |
| 28 | isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, |
| 29 | mod |
| 30 | )); |
| 31 | var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); |
| 32 | |
| 33 | // node_modules/.pnpm/commander@14.0.1/node_modules/commander/lib/error.js |
| 34 | var require_error = __commonJS({ |
| 35 | "node_modules/.pnpm/commander@14.0.1/node_modules/commander/lib/error.js"(exports2) { |
| 36 | var CommanderError2 = class extends Error { |
| 37 | /** |
| 38 | * Constructs the CommanderError class |
| 39 | * @param {number} exitCode suggested exit code which could be used with process.exit |
| 40 | * @param {string} code an id string representing the error |
| 41 | * @param {string} message human-readable description of the error |
| 42 | */ |
| 43 | constructor(exitCode, code, message) { |
| 44 | super(message); |
| 45 | Error.captureStackTrace(this, this.constructor); |
| 46 | this.name = this.constructor.name; |
| 47 | this.code = code; |
| 48 | this.exitCode = exitCode; |
| 49 | this.nestedError = void 0; |
| 50 | } |
| 51 | }; |
| 52 | var InvalidArgumentError2 = class extends CommanderError2 { |
| 53 | /** |
| 54 | * Constructs the InvalidArgumentError class |
| 55 | * @param {string} [message] explanation of why argument is invalid |
| 56 | */ |
| 57 | constructor(message) { |
| 58 | super(1, "commander.invalidArgument", message); |
| 59 | Error.captureStackTrace(this, this.constructor); |
| 60 | this.name = this.constructor.name; |
| 61 | } |
| 62 | }; |
| 63 | exports2.CommanderError = CommanderError2; |
| 64 | exports2.InvalidArgumentError = InvalidArgumentError2; |
| 65 | } |
| 66 | }); |
| 67 | |
| 68 | // node_modules/.pnpm/commander@14.0.1/node_modules/commander/lib/argument.js |
| 69 | var require_argument = __commonJS({ |
| 70 | "node_modules/.pnpm/commander@14.0.1/node_modules/commander/lib/argument.js"(exports2) { |
| 71 | var { InvalidArgumentError: InvalidArgumentError2 } = require_error(); |
| 72 | var Argument2 = class { |
| 73 | /** |
| 74 | * Initialize a new command argument with the given name and description. |
| 75 | * The default is that the argument is required, and you can explicitly |
| 76 | * indicate this with <> around the name. Put [] around the name for an optional argument. |
| 77 | * |
| 78 | * @param {string} name |
| 79 | * @param {string} [description] |
| 80 | */ |
| 81 | constructor(name, description) { |
| 82 | this.description = description || ""; |
| 83 | this.variadic = false; |
| 84 | this.parseArg = void 0; |
| 85 | this.defaultValue = void 0; |
| 86 | this.defaultValueDescription = void 0; |
| 87 | this.argChoices = void 0; |
| 88 | switch (name[0]) { |
| 89 | case "<": |
| 90 | this.required = true; |
| 91 | this._name = name.slice(1, -1); |
| 92 | break; |
| 93 | case "[": |
| 94 | this.required = false; |
| 95 | this._name = name.slice(1, -1); |
| 96 | break; |
| 97 | default: |
| 98 | this.required = true; |
| 99 | this._name = name; |
| 100 | break; |
| 101 | } |
| 102 | if (this._name.endsWith("...")) { |
| 103 | this.variadic = true; |
| 104 | this._name = this._name.slice(0, -3); |
| 105 | } |
| 106 | } |
| 107 | /** |
| 108 | * Return argument name. |
| 109 | * |
| 110 | * @return {string} |
| 111 | */ |
| 112 | name() { |
| 113 | return this._name; |
| 114 | } |
| 115 | /** |
| 116 | * @package |
| 117 | */ |
| 118 | _collectValue(value, previous) { |
| 119 | if (previous === this.defaultValue || !Array.isArray(previous)) { |
| 120 | return [value]; |
| 121 | } |
| 122 | previous.push(value); |
| 123 | return previous; |
| 124 | } |
| 125 | /** |
| 126 | * Set the default value, and optionally supply the description to be displayed in the help. |
| 127 | * |
| 128 | * @param {*} value |
| 129 | * @param {string} [description] |
| 130 | * @return {Argument} |
| 131 | */ |
| 132 | default(value, description) { |
| 133 | this.defaultValue = value; |
| 134 | this.defaultValueDescription = description; |
| 135 | return this; |
| 136 | } |
| 137 | /** |
| 138 | * Set the custom handler for processing CLI command arguments into argument values. |
| 139 | * |
| 140 | * @param {Function} [fn] |
| 141 | * @return {Argument} |
| 142 | */ |
| 143 | argParser(fn) { |
| 144 | this.parseArg = fn; |
| 145 | return this; |
| 146 | } |
| 147 | /** |
| 148 | * Only allow argument value to be one of choices. |
| 149 | * |
| 150 | * @param {string[]} values |
| 151 | * @return {Argument} |
| 152 | */ |
| 153 | choices(values) { |
| 154 | this.argChoices = values.slice(); |
| 155 | this.parseArg = (arg, previous) => { |
| 156 | if (!this.argChoices.includes(arg)) { |
| 157 | throw new InvalidArgumentError2( |
| 158 | `Allowed choices are ${this.argChoices.join(", ")}.` |
| 159 | ); |
| 160 | } |
| 161 | if (this.variadic) { |
| 162 | return this._collectValue(arg, previous); |
| 163 | } |
| 164 | return arg; |
| 165 | }; |
| 166 | return this; |
| 167 | } |
| 168 | /** |
| 169 | * Make argument required. |
| 170 | * |
| 171 | * @returns {Argument} |
| 172 | */ |
| 173 | argRequired() { |
| 174 | this.required = true; |
| 175 | return this; |
| 176 | } |
| 177 | /** |
| 178 | * Make argument optional. |
| 179 | * |
| 180 | * @returns {Argument} |
| 181 | */ |
| 182 | argOptional() { |
| 183 | this.required = false; |
| 184 | return this; |
| 185 | } |
| 186 | }; |
| 187 | function humanReadableArgName(arg) { |
| 188 | const nameOutput = arg.name() + (arg.variadic === true ? "..." : ""); |
| 189 | return arg.required ? "<" + nameOutput + ">" : "[" + nameOutput + "]"; |
| 190 | } |
| 191 | exports2.Argument = Argument2; |
| 192 | exports2.humanReadableArgName = humanReadableArgName; |
| 193 | } |
| 194 | }); |
| 195 | |
| 196 | // node_modules/.pnpm/commander@14.0.1/node_modules/commander/lib/help.js |
| 197 | var require_help = __commonJS({ |
| 198 | "node_modules/.pnpm/commander@14.0.1/node_modules/commander/lib/help.js"(exports2) { |
| 199 | var { humanReadableArgName } = require_argument(); |
| 200 | var Help2 = class { |
| 201 | constructor() { |
| 202 | this.helpWidth = void 0; |
| 203 | this.minWidthToWrap = 40; |
| 204 | this.sortSubcommands = false; |
| 205 | this.sortOptions = false; |
| 206 | this.showGlobalOptions = false; |
| 207 | } |
| 208 | /** |
| 209 | * prepareContext is called by Commander after applying overrides from `Command.configureHelp()` |
| 210 | * and just before calling `formatHelp()`. |
| 211 | * |
| 212 | * Commander just uses the helpWidth and the rest is provided for optional use by more complex subclasses. |
| 213 | * |
| 214 | * @param {{ error?: boolean, helpWidth?: number, outputHasColors?: boolean }} contextOptions |
| 215 | */ |
| 216 | prepareContext(contextOptions) { |
| 217 | this.helpWidth = this.helpWidth ?? contextOptions.helpWidth ?? 80; |
| 218 | } |
| 219 | /** |
| 220 | * Get an array of the visible subcommands. Includes a placeholder for the implicit help command, if there is one. |
| 221 | * |
| 222 | * @param {Command} cmd |
| 223 | * @returns {Command[]} |
| 224 | */ |
| 225 | visibleCommands(cmd) { |
| 226 | const visibleCommands = cmd.commands.filter((cmd2) => !cmd2._hidden); |
| 227 | const helpCommand = cmd._getHelpCommand(); |
| 228 | if (helpCommand && !helpCommand._hidden) { |
| 229 | visibleCommands.push(helpCommand); |
| 230 | } |
| 231 | if (this.sortSubcommands) { |
| 232 | visibleCommands.sort((a, b) => { |
| 233 | return a.name().localeCompare(b.name()); |
| 234 | }); |
| 235 | } |
| 236 | return visibleCommands; |
| 237 | } |
| 238 | /** |
| 239 | * Compare options for sort. |
| 240 | * |
| 241 | * @param {Option} a |
| 242 | * @param {Option} b |
| 243 | * @returns {number} |
| 244 | */ |
| 245 | compareOptions(a, b) { |
| 246 | const getSortKey = (option) => { |
| 247 | return option.short ? option.short.replace(/^-/, "") : option.long.replace(/^--/, ""); |
| 248 | }; |
| 249 | return getSortKey(a).localeCompare(getSortKey(b)); |
| 250 | } |
| 251 | /** |
| 252 | * Get an array of the visible options. Includes a placeholder for the implicit help option, if there is one. |
| 253 | * |
| 254 | * @param {Command} cmd |
| 255 | * @returns {Option[]} |
| 256 | */ |
| 257 | visibleOptions(cmd) { |
| 258 | const visibleOptions = cmd.options.filter((option) => !option.hidden); |
| 259 | const helpOption = cmd._getHelpOption(); |
| 260 | if (helpOption && !helpOption.hidden) { |
| 261 | const removeShort = helpOption.short && cmd._findOption(helpOption.short); |
| 262 | const removeLong = helpOption.long && cmd._findOption(helpOption.long); |
| 263 | if (!removeShort && !removeLong) { |
| 264 | visibleOptions.push(helpOption); |
| 265 | } else if (helpOption.long && !removeLong) { |
| 266 | visibleOptions.push( |
| 267 | cmd.createOption(helpOption.long, helpOption.description) |
| 268 | ); |
| 269 | } else if (helpOption.short && !removeShort) { |
| 270 | visibleOptions.push( |
| 271 | cmd.createOption(helpOption.short, helpOption.description) |
| 272 | ); |
| 273 | } |
| 274 | } |
| 275 | if (this.sortOptions) { |
| 276 | visibleOptions.sort(this.compareOptions); |
| 277 | } |
| 278 | return visibleOptions; |
| 279 | } |
| 280 | /** |
| 281 | * Get an array of the visible global options. (Not including help.) |
| 282 | * |
| 283 | * @param {Command} cmd |
| 284 | * @returns {Option[]} |
| 285 | */ |
| 286 | visibleGlobalOptions(cmd) { |
| 287 | if (!this.showGlobalOptions) return []; |
| 288 | const globalOptions = []; |
| 289 | for (let ancestorCmd = cmd.parent; ancestorCmd; ancestorCmd = ancestorCmd.parent) { |
| 290 | const visibleOptions = ancestorCmd.options.filter( |
| 291 | (option) => !option.hidden |
| 292 | ); |
| 293 | globalOptions.push(...visibleOptions); |
| 294 | } |
| 295 | if (this.sortOptions) { |
| 296 | globalOptions.sort(this.compareOptions); |
| 297 | } |
| 298 | return globalOptions; |
| 299 | } |
| 300 | /** |
| 301 | * Get an array of the arguments if any have a description. |
| 302 | * |
| 303 | * @param {Command} cmd |
| 304 | * @returns {Argument[]} |
| 305 | */ |
| 306 | visibleArguments(cmd) { |
| 307 | if (cmd._argsDescription) { |
| 308 | cmd.registeredArguments.forEach((argument) => { |
| 309 | argument.description = argument.description || cmd._argsDescription[argument.name()] || ""; |
| 310 | }); |
| 311 | } |
| 312 | if (cmd.registeredArguments.find((argument) => argument.description)) { |
| 313 | return cmd.registeredArguments; |
| 314 | } |
| 315 | return []; |
| 316 | } |
| 317 | /** |
| 318 | * Get the command term to show in the list of subcommands. |
| 319 | * |
| 320 | * @param {Command} cmd |
| 321 | * @returns {string} |
| 322 | */ |
| 323 | subcommandTerm(cmd) { |
| 324 | const args = cmd.registeredArguments.map((arg) => humanReadableArgName(arg)).join(" "); |
| 325 | return cmd._name + (cmd._aliases[0] ? "|" + cmd._aliases[0] : "") + (cmd.options.length ? " [options]" : "") + // simplistic check for non-help option |
| 326 | (args ? " " + args : ""); |
| 327 | } |
| 328 | /** |
| 329 | * Get the option term to show in the list of options. |
| 330 | * |
| 331 | * @param {Option} option |
| 332 | * @returns {string} |
| 333 | */ |
| 334 | optionTerm(option) { |
| 335 | return option.flags; |
| 336 | } |
| 337 | /** |
| 338 | * Get the argument term to show in the list of arguments. |
| 339 | * |
| 340 | * @param {Argument} argument |
| 341 | * @returns {string} |
| 342 | */ |
| 343 | argumentTerm(argument) { |
| 344 | return argument.name(); |
| 345 | } |
| 346 | /** |
| 347 | * Get the longest command term length. |
| 348 | * |
| 349 | * @param {Command} cmd |
| 350 | * @param {Help} helper |
| 351 | * @returns {number} |
| 352 | */ |
| 353 | longestSubcommandTermLength(cmd, helper) { |
| 354 | return helper.visibleCommands(cmd).reduce((max, command) => { |
| 355 | return Math.max( |
| 356 | max, |
| 357 | this.displayWidth( |
| 358 | helper.styleSubcommandTerm(helper.subcommandTerm(command)) |
| 359 | ) |
| 360 | ); |
| 361 | }, 0); |
| 362 | } |
| 363 | /** |
| 364 | * Get the longest option term length. |
| 365 | * |
| 366 | * @param {Command} cmd |
| 367 | * @param {Help} helper |
| 368 | * @returns {number} |
| 369 | */ |
| 370 | longestOptionTermLength(cmd, helper) { |
| 371 | return helper.visibleOptions(cmd).reduce((max, option) => { |
| 372 | return Math.max( |
| 373 | max, |
| 374 | this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option))) |
| 375 | ); |
| 376 | }, 0); |
| 377 | } |
| 378 | /** |
| 379 | * Get the longest global option term length. |
| 380 | * |
| 381 | * @param {Command} cmd |
| 382 | * @param {Help} helper |
| 383 | * @returns {number} |
| 384 | */ |
| 385 | longestGlobalOptionTermLength(cmd, helper) { |
| 386 | return helper.visibleGlobalOptions(cmd).reduce((max, option) => { |
| 387 | return Math.max( |
| 388 | max, |
| 389 | this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option))) |
| 390 | ); |
| 391 | }, 0); |
| 392 | } |
| 393 | /** |
| 394 | * Get the longest argument term length. |
| 395 | * |
| 396 | * @param {Command} cmd |
| 397 | * @param {Help} helper |
| 398 | * @returns {number} |
| 399 | */ |
| 400 | longestArgumentTermLength(cmd, helper) { |
| 401 | return helper.visibleArguments(cmd).reduce((max, argument) => { |
| 402 | return Math.max( |
| 403 | max, |
| 404 | this.displayWidth( |
| 405 | helper.styleArgumentTerm(helper.argumentTerm(argument)) |
| 406 | ) |
| 407 | ); |
| 408 | }, 0); |
| 409 | } |
| 410 | /** |
| 411 | * Get the command usage to be displayed at the top of the built-in help. |
| 412 | * |
| 413 | * @param {Command} cmd |
| 414 | * @returns {string} |
| 415 | */ |
| 416 | commandUsage(cmd) { |
| 417 | let cmdName = cmd._name; |
| 418 | if (cmd._aliases[0]) { |
| 419 | cmdName = cmdName + "|" + cmd._aliases[0]; |
| 420 | } |
| 421 | let ancestorCmdNames = ""; |
| 422 | for (let ancestorCmd = cmd.parent; ancestorCmd; ancestorCmd = ancestorCmd.parent) { |
| 423 | ancestorCmdNames = ancestorCmd.name() + " " + ancestorCmdNames; |
| 424 | } |
| 425 | return ancestorCmdNames + cmdName + " " + cmd.usage(); |
| 426 | } |
| 427 | /** |
| 428 | * Get the description for the command. |
| 429 | * |
| 430 | * @param {Command} cmd |
| 431 | * @returns {string} |
| 432 | */ |
| 433 | commandDescription(cmd) { |
| 434 | return cmd.description(); |
| 435 | } |
| 436 | /** |
| 437 | * Get the subcommand summary to show in the list of subcommands. |
| 438 | * (Fallback to description for backwards compatibility.) |
| 439 | * |
| 440 | * @param {Command} cmd |
| 441 | * @returns {string} |
| 442 | */ |
| 443 | subcommandDescription(cmd) { |
| 444 | return cmd.summary() || cmd.description(); |
| 445 | } |
| 446 | /** |
| 447 | * Get the option description to show in the list of options. |
| 448 | * |
| 449 | * @param {Option} option |
| 450 | * @return {string} |
| 451 | */ |
| 452 | optionDescription(option) { |
| 453 | const extraInfo = []; |
| 454 | if (option.argChoices) { |
| 455 | extraInfo.push( |
| 456 | // use stringify to match the display of the default value |
| 457 | `choices: ${option.argChoices.map((choice) => JSON.stringify(choice)).join(", ")}` |
| 458 | ); |
| 459 | } |
| 460 | if (option.defaultValue !== void 0) { |
| 461 | const showDefault = option.required || option.optional || option.isBoolean() && typeof option.defaultValue === "boolean"; |
| 462 | if (showDefault) { |
| 463 | extraInfo.push( |
| 464 | `default: ${option.defaultValueDescription || JSON.stringify(option.defaultValue)}` |
| 465 | ); |
| 466 | } |
| 467 | } |
| 468 | if (option.presetArg !== void 0 && option.optional) { |
| 469 | extraInfo.push(`preset: ${JSON.stringify(option.presetArg)}`); |
| 470 | } |
| 471 | if (option.envVar !== void 0) { |
| 472 | extraInfo.push(`env: ${option.envVar}`); |
| 473 | } |
| 474 | if (extraInfo.length > 0) { |
| 475 | const extraDescription = `(${extraInfo.join(", ")})`; |
| 476 | if (option.description) { |
| 477 | return `${option.description} ${extraDescription}`; |
| 478 | } |
| 479 | return extraDescription; |
| 480 | } |
| 481 | return option.description; |
| 482 | } |
| 483 | /** |
| 484 | * Get the argument description to show in the list of arguments. |
| 485 | * |
| 486 | * @param {Argument} argument |
| 487 | * @return {string} |
| 488 | */ |
| 489 | argumentDescription(argument) { |
| 490 | const extraInfo = []; |
| 491 | if (argument.argChoices) { |
| 492 | extraInfo.push( |
| 493 | // use stringify to match the display of the default value |
| 494 | `choices: ${argument.argChoices.map((choice) => JSON.stringify(choice)).join(", ")}` |
| 495 | ); |
| 496 | } |
| 497 | if (argument.defaultValue !== void 0) { |
| 498 | extraInfo.push( |
| 499 | `default: ${argument.defaultValueDescription || JSON.stringify(argument.defaultValue)}` |
| 500 | ); |
| 501 | } |
| 502 | if (extraInfo.length > 0) { |
| 503 | const extraDescription = `(${extraInfo.join(", ")})`; |
| 504 | if (argument.description) { |
| 505 | return `${argument.description} ${extraDescription}`; |
| 506 | } |
| 507 | return extraDescription; |
| 508 | } |
| 509 | return argument.description; |
| 510 | } |
| 511 | /** |
| 512 | * Format a list of items, given a heading and an array of formatted items. |
| 513 | * |
| 514 | * @param {string} heading |
| 515 | * @param {string[]} items |
| 516 | * @param {Help} helper |
| 517 | * @returns string[] |
| 518 | */ |
| 519 | formatItemList(heading, items, helper) { |
| 520 | if (items.length === 0) return []; |
| 521 | return [helper.styleTitle(heading), ...items, ""]; |
| 522 | } |
| 523 | /** |
| 524 | * Group items by their help group heading. |
| 525 | * |
| 526 | * @param {Command[] | Option[]} unsortedItems |
| 527 | * @param {Command[] | Option[]} visibleItems |
| 528 | * @param {Function} getGroup |
| 529 | * @returns {Map<string, Command[] | Option[]>} |
| 530 | */ |
| 531 | groupItems(unsortedItems, visibleItems, getGroup) { |
| 532 | const result = /* @__PURE__ */ new Map(); |
| 533 | unsortedItems.forEach((item) => { |
| 534 | const group = getGroup(item); |
| 535 | if (!result.has(group)) result.set(group, []); |
| 536 | }); |
| 537 | visibleItems.forEach((item) => { |
| 538 | const group = getGroup(item); |
| 539 | if (!result.has(group)) { |
| 540 | result.set(group, []); |
| 541 | } |
| 542 | result.get(group).push(item); |
| 543 | }); |
| 544 | return result; |
| 545 | } |
| 546 | /** |
| 547 | * Generate the built-in help text. |
| 548 | * |
| 549 | * @param {Command} cmd |
| 550 | * @param {Help} helper |
| 551 | * @returns {string} |
| 552 | */ |
| 553 | formatHelp(cmd, helper) { |
| 554 | const termWidth = helper.padWidth(cmd, helper); |
| 555 | const helpWidth = helper.helpWidth ?? 80; |
| 556 | function callFormatItem(term, description) { |
| 557 | return helper.formatItem(term, termWidth, description, helper); |
| 558 | } |
| 559 | let output = [ |
| 560 | `${helper.styleTitle("Usage:")} ${helper.styleUsage(helper.commandUsage(cmd))}`, |
| 561 | "" |
| 562 | ]; |
| 563 | const commandDescription = helper.commandDescription(cmd); |
| 564 | if (commandDescription.length > 0) { |
| 565 | output = output.concat([ |
| 566 | helper.boxWrap( |
| 567 | helper.styleCommandDescription(commandDescription), |
| 568 | helpWidth |
| 569 | ), |
| 570 | "" |
| 571 | ]); |
| 572 | } |
| 573 | const argumentList = helper.visibleArguments(cmd).map((argument) => { |
| 574 | return callFormatItem( |
| 575 | helper.styleArgumentTerm(helper.argumentTerm(argument)), |
| 576 | helper.styleArgumentDescription(helper.argumentDescription(argument)) |
| 577 | ); |
| 578 | }); |
| 579 | output = output.concat( |
| 580 | this.formatItemList("Arguments:", argumentList, helper) |
| 581 | ); |
| 582 | const optionGroups = this.groupItems( |
| 583 | cmd.options, |
| 584 | helper.visibleOptions(cmd), |
| 585 | (option) => option.helpGroupHeading ?? "Options:" |
| 586 | ); |
| 587 | optionGroups.forEach((options, group) => { |
| 588 | const optionList = options.map((option) => { |
| 589 | return callFormatItem( |
| 590 | helper.styleOptionTerm(helper.optionTerm(option)), |
| 591 | helper.styleOptionDescription(helper.optionDescription(option)) |
| 592 | ); |
| 593 | }); |
| 594 | output = output.concat(this.formatItemList(group, optionList, helper)); |
| 595 | }); |
| 596 | if (helper.showGlobalOptions) { |
| 597 | const globalOptionList = helper.visibleGlobalOptions(cmd).map((option) => { |
| 598 | return callFormatItem( |
| 599 | helper.styleOptionTerm(helper.optionTerm(option)), |
| 600 | helper.styleOptionDescription(helper.optionDescription(option)) |
| 601 | ); |
| 602 | }); |
| 603 | output = output.concat( |
| 604 | this.formatItemList("Global Options:", globalOptionList, helper) |
| 605 | ); |
| 606 | } |
| 607 | const commandGroups = this.groupItems( |
| 608 | cmd.commands, |
| 609 | helper.visibleCommands(cmd), |
| 610 | (sub) => sub.helpGroup() || "Commands:" |
| 611 | ); |
| 612 | commandGroups.forEach((commands, group) => { |
| 613 | const commandList = commands.map((sub) => { |
| 614 | return callFormatItem( |
| 615 | helper.styleSubcommandTerm(helper.subcommandTerm(sub)), |
| 616 | helper.styleSubcommandDescription(helper.subcommandDescription(sub)) |
| 617 | ); |
| 618 | }); |
| 619 | output = output.concat(this.formatItemList(group, commandList, helper)); |
| 620 | }); |
| 621 | return output.join("\n"); |
| 622 | } |
| 623 | /** |
| 624 | * Return display width of string, ignoring ANSI escape sequences. Used in padding and wrapping calculations. |
| 625 | * |
| 626 | * @param {string} str |
| 627 | * @returns {number} |
| 628 | */ |
| 629 | displayWidth(str) { |
| 630 | return stripColor(str).length; |
| 631 | } |
| 632 | /** |
| 633 | * Style the title for displaying in the help. Called with 'Usage:', 'Options:', etc. |
| 634 | * |
| 635 | * @param {string} str |
| 636 | * @returns {string} |
| 637 | */ |
| 638 | styleTitle(str) { |
| 639 | return str; |
| 640 | } |
| 641 | styleUsage(str) { |
| 642 | return str.split(" ").map((word) => { |
| 643 | if (word === "[options]") return this.styleOptionText(word); |
| 644 | if (word === "[command]") return this.styleSubcommandText(word); |
| 645 | if (word[0] === "[" || word[0] === "<") |
| 646 | return this.styleArgumentText(word); |
| 647 | return this.styleCommandText(word); |
| 648 | }).join(" "); |
| 649 | } |
| 650 | styleCommandDescription(str) { |
| 651 | return this.styleDescriptionText(str); |
| 652 | } |
| 653 | styleOptionDescription(str) { |
| 654 | return this.styleDescriptionText(str); |
| 655 | } |
| 656 | styleSubcommandDescription(str) { |
| 657 | return this.styleDescriptionText(str); |
| 658 | } |
| 659 | styleArgumentDescription(str) { |
| 660 | return this.styleDescriptionText(str); |
| 661 | } |
| 662 | styleDescriptionText(str) { |
| 663 | return str; |
| 664 | } |
| 665 | styleOptionTerm(str) { |
| 666 | return this.styleOptionText(str); |
| 667 | } |
| 668 | styleSubcommandTerm(str) { |
| 669 | return str.split(" ").map((word) => { |
| 670 | if (word === "[options]") return this.styleOptionText(word); |
| 671 | if (word[0] === "[" || word[0] === "<") |
| 672 | return this.styleArgumentText(word); |
| 673 | return this.styleSubcommandText(word); |
| 674 | }).join(" "); |
| 675 | } |
| 676 | styleArgumentTerm(str) { |
| 677 | return this.styleArgumentText(str); |
| 678 | } |
| 679 | styleOptionText(str) { |
| 680 | return str; |
| 681 | } |
| 682 | styleArgumentText(str) { |
| 683 | return str; |
| 684 | } |
| 685 | styleSubcommandText(str) { |
| 686 | return str; |
| 687 | } |
| 688 | styleCommandText(str) { |
| 689 | return str; |
| 690 | } |
| 691 | /** |
| 692 | * Calculate the pad width from the maximum term length. |
| 693 | * |
| 694 | * @param {Command} cmd |
| 695 | * @param {Help} helper |
| 696 | * @returns {number} |
| 697 | */ |
| 698 | padWidth(cmd, helper) { |
| 699 | return Math.max( |
| 700 | helper.longestOptionTermLength(cmd, helper), |
| 701 | helper.longestGlobalOptionTermLength(cmd, helper), |
| 702 | helper.longestSubcommandTermLength(cmd, helper), |
| 703 | helper.longestArgumentTermLength(cmd, helper) |
| 704 | ); |
| 705 | } |
| 706 | /** |
| 707 | * Detect manually wrapped and indented strings by checking for line break followed by whitespace. |
| 708 | * |
| 709 | * @param {string} str |
| 710 | * @returns {boolean} |
| 711 | */ |
| 712 | preformatted(str) { |
| 713 | return /\n[^\S\r\n]/.test(str); |
| 714 | } |
| 715 | /** |
| 716 | * Format the "item", which consists of a term and description. Pad the term and wrap the description, indenting the following lines. |
| 717 | * |
| 718 | * So "TTT", 5, "DDD DDDD DD DDD" might be formatted for this.helpWidth=17 like so: |
| 719 | * TTT DDD DDDD |
| 720 | * DD DDD |
| 721 | * |
| 722 | * @param {string} term |
| 723 | * @param {number} termWidth |
| 724 | * @param {string} description |
| 725 | * @param {Help} helper |
| 726 | * @returns {string} |
| 727 | */ |
| 728 | formatItem(term, termWidth, description, helper) { |
| 729 | const itemIndent = 2; |
| 730 | const itemIndentStr = " ".repeat(itemIndent); |
| 731 | if (!description) return itemIndentStr + term; |
| 732 | const paddedTerm = term.padEnd( |
| 733 | termWidth + term.length - helper.displayWidth(term) |
| 734 | ); |
| 735 | const spacerWidth = 2; |
| 736 | const helpWidth = this.helpWidth ?? 80; |
| 737 | const remainingWidth = helpWidth - termWidth - spacerWidth - itemIndent; |
| 738 | let formattedDescription; |
| 739 | if (remainingWidth < this.minWidthToWrap || helper.preformatted(description)) { |
| 740 | formattedDescription = description; |
| 741 | } else { |
| 742 | const wrappedDescription = helper.boxWrap(description, remainingWidth); |
| 743 | formattedDescription = wrappedDescription.replace( |
| 744 | /\n/g, |
| 745 | "\n" + " ".repeat(termWidth + spacerWidth) |
| 746 | ); |
| 747 | } |
| 748 | return itemIndentStr + paddedTerm + " ".repeat(spacerWidth) + formattedDescription.replace(/\n/g, ` |
| 749 | ${itemIndentStr}`); |
| 750 | } |
| 751 | /** |
| 752 | * Wrap a string at whitespace, preserving existing line breaks. |
| 753 | * Wrapping is skipped if the width is less than `minWidthToWrap`. |
| 754 | * |
| 755 | * @param {string} str |
| 756 | * @param {number} width |
| 757 | * @returns {string} |
| 758 | */ |
| 759 | boxWrap(str, width) { |
| 760 | if (width < this.minWidthToWrap) return str; |
| 761 | const rawLines = str.split(/\r\n|\n/); |
| 762 | const chunkPattern = /[\s]*[^\s]+/g; |
| 763 | const wrappedLines = []; |
| 764 | rawLines.forEach((line) => { |
| 765 | const chunks = line.match(chunkPattern); |
| 766 | if (chunks === null) { |
| 767 | wrappedLines.push(""); |
| 768 | return; |
| 769 | } |
| 770 | let sumChunks = [chunks.shift()]; |
| 771 | let sumWidth = this.displayWidth(sumChunks[0]); |
| 772 | chunks.forEach((chunk) => { |
| 773 | const visibleWidth = this.displayWidth(chunk); |
| 774 | if (sumWidth + visibleWidth <= width) { |
| 775 | sumChunks.push(chunk); |
| 776 | sumWidth += visibleWidth; |
| 777 | return; |
| 778 | } |
| 779 | wrappedLines.push(sumChunks.join("")); |
| 780 | const nextChunk = chunk.trimStart(); |
| 781 | sumChunks = [nextChunk]; |
| 782 | sumWidth = this.displayWidth(nextChunk); |
| 783 | }); |
| 784 | wrappedLines.push(sumChunks.join("")); |
| 785 | }); |
| 786 | return wrappedLines.join("\n"); |
| 787 | } |
| 788 | }; |
| 789 | function stripColor(str) { |
| 790 | const sgrPattern = /\x1b\[\d*(;\d*)*m/g; |
| 791 | return str.replace(sgrPattern, ""); |
| 792 | } |
| 793 | exports2.Help = Help2; |
| 794 | exports2.stripColor = stripColor; |
| 795 | } |
| 796 | }); |
| 797 | |
| 798 | // node_modules/.pnpm/commander@14.0.1/node_modules/commander/lib/option.js |
| 799 | var require_option = __commonJS({ |
| 800 | "node_modules/.pnpm/commander@14.0.1/node_modules/commander/lib/option.js"(exports2) { |
| 801 | var { InvalidArgumentError: InvalidArgumentError2 } = require_error(); |
| 802 | var Option2 = class { |
| 803 | /** |
| 804 | * Initialize a new `Option` with the given `flags` and `description`. |
| 805 | * |
| 806 | * @param {string} flags |
| 807 | * @param {string} [description] |
| 808 | */ |
| 809 | constructor(flags, description) { |
| 810 | this.flags = flags; |
| 811 | this.description = description || ""; |
| 812 | this.required = flags.includes("<"); |
| 813 | this.optional = flags.includes("["); |
| 814 | this.variadic = /\w\.\.\.[>\]]$/.test(flags); |
| 815 | this.mandatory = false; |
| 816 | const optionFlags = splitOptionFlags(flags); |
| 817 | this.short = optionFlags.shortFlag; |
| 818 | this.long = optionFlags.longFlag; |
| 819 | this.negate = false; |
| 820 | if (this.long) { |
| 821 | this.negate = this.long.startsWith("--no-"); |
| 822 | } |
| 823 | this.defaultValue = void 0; |
| 824 | this.defaultValueDescription = void 0; |
| 825 | this.presetArg = void 0; |
| 826 | this.envVar = void 0; |
| 827 | this.parseArg = void 0; |
| 828 | this.hidden = false; |
| 829 | this.argChoices = void 0; |
| 830 | this.conflictsWith = []; |
| 831 | this.implied = void 0; |
| 832 | this.helpGroupHeading = void 0; |
| 833 | } |
| 834 | /** |
| 835 | * Set the default value, and optionally supply the description to be displayed in the help. |
| 836 | * |
| 837 | * @param {*} value |
| 838 | * @param {string} [description] |
| 839 | * @return {Option} |
| 840 | */ |
| 841 | default(value, description) { |
| 842 | this.defaultValue = value; |
| 843 | this.defaultValueDescription = description; |
| 844 | return this; |
| 845 | } |
| 846 | /** |
| 847 | * Preset to use when option used without option-argument, especially optional but also boolean and negated. |
| 848 | * The custom processing (parseArg) is called. |
| 849 | * |
| 850 | * @example |
| 851 | * new Option('--color').default('GREYSCALE').preset('RGB'); |
| 852 | * new Option('--donate [amount]').preset('20').argParser(parseFloat); |
| 853 | * |
| 854 | * @param {*} arg |
| 855 | * @return {Option} |
| 856 | */ |
| 857 | preset(arg) { |
| 858 | this.presetArg = arg; |
| 859 | return this; |
| 860 | } |
| 861 | /** |
| 862 | * Add option name(s) that conflict with this option. |
| 863 | * An error will be displayed if conflicting options are found during parsing. |
| 864 | * |
| 865 | * @example |
| 866 | * new Option('--rgb').conflicts('cmyk'); |
| 867 | * new Option('--js').conflicts(['ts', 'jsx']); |
| 868 | * |
| 869 | * @param {(string | string[])} names |
| 870 | * @return {Option} |
| 871 | */ |
| 872 | conflicts(names) { |
| 873 | this.conflictsWith = this.conflictsWith.concat(names); |
| 874 | return this; |
| 875 | } |
| 876 | /** |
| 877 | * Specify implied option values for when this option is set and the implied options are not. |
| 878 | * |
| 879 | * The custom processing (parseArg) is not called on the implied values. |
| 880 | * |
| 881 | * @example |
| 882 | * program |
| 883 | * .addOption(new Option('--log', 'write logging information to file')) |
| 884 | * .addOption(new Option('--trace', 'log extra details').implies({ log: 'trace.txt' })); |
| 885 | * |
| 886 | * @param {object} impliedOptionValues |
| 887 | * @return {Option} |
| 888 | */ |
| 889 | implies(impliedOptionValues) { |
| 890 | let newImplied = impliedOptionValues; |
| 891 | if (typeof impliedOptionValues === "string") { |
| 892 | newImplied = { [impliedOptionValues]: true }; |
| 893 | } |
| 894 | this.implied = Object.assign(this.implied || {}, newImplied); |
| 895 | return this; |
| 896 | } |
| 897 | /** |
| 898 | * Set environment variable to check for option value. |
| 899 | * |
| 900 | * An environment variable is only used if when processed the current option value is |
| 901 | * undefined, or the source of the current value is 'default' or 'config' or 'env'. |
| 902 | * |
| 903 | * @param {string} name |
| 904 | * @return {Option} |
| 905 | */ |
| 906 | env(name) { |
| 907 | this.envVar = name; |
| 908 | return this; |
| 909 | } |
| 910 | /** |
| 911 | * Set the custom handler for processing CLI option arguments into option values. |
| 912 | * |
| 913 | * @param {Function} [fn] |
| 914 | * @return {Option} |
| 915 | */ |
| 916 | argParser(fn) { |
| 917 | this.parseArg = fn; |
| 918 | return this; |
| 919 | } |
| 920 | /** |
| 921 | * Whether the option is mandatory and must have a value after parsing. |
| 922 | * |
| 923 | * @param {boolean} [mandatory=true] |
| 924 | * @return {Option} |
| 925 | */ |
| 926 | makeOptionMandatory(mandatory = true) { |
| 927 | this.mandatory = !!mandatory; |
| 928 | return this; |
| 929 | } |
| 930 | /** |
| 931 | * Hide option in help. |
| 932 | * |
| 933 | * @param {boolean} [hide=true] |
| 934 | * @return {Option} |
| 935 | */ |
| 936 | hideHelp(hide = true) { |
| 937 | this.hidden = !!hide; |
| 938 | return this; |
| 939 | } |
| 940 | /** |
| 941 | * @package |
| 942 | */ |
| 943 | _collectValue(value, previous) { |
| 944 | if (previous === this.defaultValue || !Array.isArray(previous)) { |
| 945 | return [value]; |
| 946 | } |
| 947 | previous.push(value); |
| 948 | return previous; |
| 949 | } |
| 950 | /** |
| 951 | * Only allow option value to be one of choices. |
| 952 | * |
| 953 | * @param {string[]} values |
| 954 | * @return {Option} |
| 955 | */ |
| 956 | choices(values) { |
| 957 | this.argChoices = values.slice(); |
| 958 | this.parseArg = (arg, previous) => { |
| 959 | if (!this.argChoices.includes(arg)) { |
| 960 | throw new InvalidArgumentError2( |
| 961 | `Allowed choices are ${this.argChoices.join(", ")}.` |
| 962 | ); |
| 963 | } |
| 964 | if (this.variadic) { |
| 965 | return this._collectValue(arg, previous); |
| 966 | } |
| 967 | return arg; |
| 968 | }; |
| 969 | return this; |
| 970 | } |
| 971 | /** |
| 972 | * Return option name. |
| 973 | * |
| 974 | * @return {string} |
| 975 | */ |
| 976 | name() { |
| 977 | if (this.long) { |
| 978 | return this.long.replace(/^--/, ""); |
| 979 | } |
| 980 | return this.short.replace(/^-/, ""); |
| 981 | } |
| 982 | /** |
| 983 | * Return option name, in a camelcase format that can be used |
| 984 | * as an object attribute key. |
| 985 | * |
| 986 | * @return {string} |
| 987 | */ |
| 988 | attributeName() { |
| 989 | if (this.negate) { |
| 990 | return camelcase(this.name().replace(/^no-/, "")); |
| 991 | } |
| 992 | return camelcase(this.name()); |
| 993 | } |
| 994 | /** |
| 995 | * Set the help group heading. |
| 996 | * |
| 997 | * @param {string} heading |
| 998 | * @return {Option} |
| 999 | */ |
| 1000 | helpGroup(heading) { |
| 1001 | this.helpGroupHeading = heading; |
| 1002 | return this; |
| 1003 | } |
| 1004 | /** |
| 1005 | * Check if `arg` matches the short or long flag. |
| 1006 | * |
| 1007 | * @param {string} arg |
| 1008 | * @return {boolean} |
| 1009 | * @package |
| 1010 | */ |
| 1011 | is(arg) { |
| 1012 | return this.short === arg || this.long === arg; |
| 1013 | } |
| 1014 | /** |
| 1015 | * Return whether a boolean option. |
| 1016 | * |
| 1017 | * Options are one of boolean, negated, required argument, or optional argument. |
| 1018 | * |
| 1019 | * @return {boolean} |
| 1020 | * @package |
| 1021 | */ |
| 1022 | isBoolean() { |
| 1023 | return !this.required && !this.optional && !this.negate; |
| 1024 | } |
| 1025 | }; |
| 1026 | var DualOptions = class { |
| 1027 | /** |
| 1028 | * @param {Option[]} options |
| 1029 | */ |
| 1030 | constructor(options) { |
| 1031 | this.positiveOptions = /* @__PURE__ */ new Map(); |
| 1032 | this.negativeOptions = /* @__PURE__ */ new Map(); |
| 1033 | this.dualOptions = /* @__PURE__ */ new Set(); |
| 1034 | options.forEach((option) => { |
| 1035 | if (option.negate) { |
| 1036 | this.negativeOptions.set(option.attributeName(), option); |
| 1037 | } else { |
| 1038 | this.positiveOptions.set(option.attributeName(), option); |
| 1039 | } |
| 1040 | }); |
| 1041 | this.negativeOptions.forEach((value, key) => { |
| 1042 | if (this.positiveOptions.has(key)) { |
| 1043 | this.dualOptions.add(key); |
| 1044 | } |
| 1045 | }); |
| 1046 | } |
| 1047 | /** |
| 1048 | * Did the value come from the option, and not from possible matching dual option? |
| 1049 | * |
| 1050 | * @param {*} value |
| 1051 | * @param {Option} option |
| 1052 | * @returns {boolean} |
| 1053 | */ |
| 1054 | valueFromOption(value, option) { |
| 1055 | const optionKey = option.attributeName(); |
| 1056 | if (!this.dualOptions.has(optionKey)) return true; |
| 1057 | const preset = this.negativeOptions.get(optionKey).presetArg; |
| 1058 | const negativeValue = preset !== void 0 ? preset : false; |
| 1059 | return option.negate === (negativeValue === value); |
| 1060 | } |
| 1061 | }; |
| 1062 | function camelcase(str) { |
| 1063 | return str.split("-").reduce((str2, word) => { |
| 1064 | return str2 + word[0].toUpperCase() + word.slice(1); |
| 1065 | }); |
| 1066 | } |
| 1067 | function splitOptionFlags(flags) { |
| 1068 | let shortFlag; |
| 1069 | let longFlag; |
| 1070 | const shortFlagExp = /^-[^-]$/; |
| 1071 | const longFlagExp = /^--[^-]/; |
| 1072 | const flagParts = flags.split(/[ |,]+/).concat("guard"); |
| 1073 | if (shortFlagExp.test(flagParts[0])) shortFlag = flagParts.shift(); |
| 1074 | if (longFlagExp.test(flagParts[0])) longFlag = flagParts.shift(); |
| 1075 | if (!shortFlag && shortFlagExp.test(flagParts[0])) |
| 1076 | shortFlag = flagParts.shift(); |
| 1077 | if (!shortFlag && longFlagExp.test(flagParts[0])) { |
| 1078 | shortFlag = longFlag; |
| 1079 | longFlag = flagParts.shift(); |
| 1080 | } |
| 1081 | if (flagParts[0].startsWith("-")) { |
| 1082 | const unsupportedFlag = flagParts[0]; |
| 1083 | const baseError = `option creation failed due to '${unsupportedFlag}' in option flags '${flags}'`; |
| 1084 | if (/^-[^-][^-]/.test(unsupportedFlag)) |
| 1085 | throw new Error( |
| 1086 | `${baseError} |
| 1087 | - a short flag is a single dash and a single character |
| 1088 | - either use a single dash and a single character (for a short flag) |
| 1089 | - or use a double dash for a long option (and can have two, like '--ws, --workspace')` |
| 1090 | ); |
| 1091 | if (shortFlagExp.test(unsupportedFlag)) |
| 1092 | throw new Error(`${baseError} |
| 1093 | - too many short flags`); |
| 1094 | if (longFlagExp.test(unsupportedFlag)) |
| 1095 | throw new Error(`${baseError} |
| 1096 | - too many long flags`); |
| 1097 | throw new Error(`${baseError} |
| 1098 | - unrecognised flag format`); |
| 1099 | } |
| 1100 | if (shortFlag === void 0 && longFlag === void 0) |
| 1101 | throw new Error( |
| 1102 | `option creation failed due to no flags found in '${flags}'.` |
| 1103 | ); |
| 1104 | return { shortFlag, longFlag }; |
| 1105 | } |
| 1106 | exports2.Option = Option2; |
| 1107 | exports2.DualOptions = DualOptions; |
| 1108 | } |
| 1109 | }); |
| 1110 | |
| 1111 | // node_modules/.pnpm/commander@14.0.1/node_modules/commander/lib/suggestSimilar.js |
| 1112 | var require_suggestSimilar = __commonJS({ |
| 1113 | "node_modules/.pnpm/commander@14.0.1/node_modules/commander/lib/suggestSimilar.js"(exports2) { |
| 1114 | var maxDistance = 3; |
| 1115 | function editDistance(a, b) { |
| 1116 | if (Math.abs(a.length - b.length) > maxDistance) |
| 1117 | return Math.max(a.length, b.length); |
| 1118 | const d = []; |
| 1119 | for (let i = 0; i <= a.length; i++) { |
| 1120 | d[i] = [i]; |
| 1121 | } |
| 1122 | for (let j = 0; j <= b.length; j++) { |
| 1123 | d[0][j] = j; |
| 1124 | } |
| 1125 | for (let j = 1; j <= b.length; j++) { |
| 1126 | for (let i = 1; i <= a.length; i++) { |
| 1127 | let cost = 1; |
| 1128 | if (a[i - 1] === b[j - 1]) { |
| 1129 | cost = 0; |
| 1130 | } else { |
| 1131 | cost = 1; |
| 1132 | } |
| 1133 | d[i][j] = Math.min( |
| 1134 | d[i - 1][j] + 1, |
| 1135 | // deletion |
| 1136 | d[i][j - 1] + 1, |
| 1137 | // insertion |
| 1138 | d[i - 1][j - 1] + cost |
| 1139 | // substitution |
| 1140 | ); |
| 1141 | if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) { |
| 1142 | d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1); |
| 1143 | } |
| 1144 | } |
| 1145 | } |
| 1146 | return d[a.length][b.length]; |
| 1147 | } |
| 1148 | function suggestSimilar(word, candidates) { |
| 1149 | if (!candidates || candidates.length === 0) return ""; |
| 1150 | candidates = Array.from(new Set(candidates)); |
| 1151 | const searchingOptions = word.startsWith("--"); |
| 1152 | if (searchingOptions) { |
| 1153 | word = word.slice(2); |
| 1154 | candidates = candidates.map((candidate) => candidate.slice(2)); |
| 1155 | } |
| 1156 | let similar = []; |
| 1157 | let bestDistance = maxDistance; |
| 1158 | const minSimilarity = 0.4; |
| 1159 | candidates.forEach((candidate) => { |
| 1160 | if (candidate.length <= 1) return; |
| 1161 | const distance = editDistance(word, candidate); |
| 1162 | const length = Math.max(word.length, candidate.length); |
| 1163 | const similarity = (length - distance) / length; |
| 1164 | if (similarity > minSimilarity) { |
| 1165 | if (distance < bestDistance) { |
| 1166 | bestDistance = distance; |
| 1167 | similar = [candidate]; |
| 1168 | } else if (distance === bestDistance) { |
| 1169 | similar.push(candidate); |
| 1170 | } |
| 1171 | } |
| 1172 | }); |
| 1173 | similar.sort((a, b) => a.localeCompare(b)); |
| 1174 | if (searchingOptions) { |
| 1175 | similar = similar.map((candidate) => `--${candidate}`); |
| 1176 | } |
| 1177 | if (similar.length > 1) { |
| 1178 | return ` |
| 1179 | (Did you mean one of ${similar.join(", ")}?)`; |
| 1180 | } |
| 1181 | if (similar.length === 1) { |
| 1182 | return ` |
| 1183 | (Did you mean ${similar[0]}?)`; |
| 1184 | } |
| 1185 | return ""; |
| 1186 | } |
| 1187 | exports2.suggestSimilar = suggestSimilar; |
| 1188 | } |
| 1189 | }); |
| 1190 | |
| 1191 | // node_modules/.pnpm/commander@14.0.1/node_modules/commander/lib/command.js |
| 1192 | var require_command = __commonJS({ |
| 1193 | "node_modules/.pnpm/commander@14.0.1/node_modules/commander/lib/command.js"(exports2) { |
| 1194 | var EventEmitter = require("node:events").EventEmitter; |
| 1195 | var childProcess = require("node:child_process"); |
| 1196 | var path5 = require("node:path"); |
| 1197 | var fs5 = require("node:fs"); |
| 1198 | var process2 = require("node:process"); |
| 1199 | var { Argument: Argument2, humanReadableArgName } = require_argument(); |
| 1200 | var { CommanderError: CommanderError2 } = require_error(); |
| 1201 | var { Help: Help2, stripColor } = require_help(); |
| 1202 | var { Option: Option2, DualOptions } = require_option(); |
| 1203 | var { suggestSimilar } = require_suggestSimilar(); |
| 1204 | var Command2 = class _Command extends EventEmitter { |
| 1205 | /** |
| 1206 | * Initialize a new `Command`. |
| 1207 | * |
| 1208 | * @param {string} [name] |
| 1209 | */ |
| 1210 | constructor(name) { |
| 1211 | super(); |
| 1212 | this.commands = []; |
| 1213 | this.options = []; |
| 1214 | this.parent = null; |
| 1215 | this._allowUnknownOption = false; |
| 1216 | this._allowExcessArguments = false; |
| 1217 | this.registeredArguments = []; |
| 1218 | this._args = this.registeredArguments; |
| 1219 | this.args = []; |
| 1220 | this.rawArgs = []; |
| 1221 | this.processedArgs = []; |
| 1222 | this._scriptPath = null; |
| 1223 | this._name = name || ""; |
| 1224 | this._optionValues = {}; |
| 1225 | this._optionValueSources = {}; |
| 1226 | this._storeOptionsAsProperties = false; |
| 1227 | this._actionHandler = null; |
| 1228 | this._executableHandler = false; |
| 1229 | this._executableFile = null; |
| 1230 | this._executableDir = null; |
| 1231 | this._defaultCommandName = null; |
| 1232 | this._exitCallback = null; |
| 1233 | this._aliases = []; |
| 1234 | this._combineFlagAndOptionalValue = true; |
| 1235 | this._description = ""; |
| 1236 | this._summary = ""; |
| 1237 | this._argsDescription = void 0; |
| 1238 | this._enablePositionalOptions = false; |
| 1239 | this._passThroughOptions = false; |
| 1240 | this._lifeCycleHooks = {}; |
| 1241 | this._showHelpAfterError = false; |
| 1242 | this._showSuggestionAfterError = true; |
| 1243 | this._savedState = null; |
| 1244 | this._outputConfiguration = { |
| 1245 | writeOut: (str) => process2.stdout.write(str), |
| 1246 | writeErr: (str) => process2.stderr.write(str), |
| 1247 | outputError: (str, write) => write(str), |
| 1248 | getOutHelpWidth: () => process2.stdout.isTTY ? process2.stdout.columns : void 0, |
| 1249 | getErrHelpWidth: () => process2.stderr.isTTY ? process2.stderr.columns : void 0, |
| 1250 | getOutHasColors: () => useColor() ?? (process2.stdout.isTTY && process2.stdout.hasColors?.()), |
| 1251 | getErrHasColors: () => useColor() ?? (process2.stderr.isTTY && process2.stderr.hasColors?.()), |
| 1252 | stripColor: (str) => stripColor(str) |
| 1253 | }; |
| 1254 | this._hidden = false; |
| 1255 | this._helpOption = void 0; |
| 1256 | this._addImplicitHelpCommand = void 0; |
| 1257 | this._helpCommand = void 0; |
| 1258 | this._helpConfiguration = {}; |
| 1259 | this._helpGroupHeading = void 0; |
| 1260 | this._defaultCommandGroup = void 0; |
| 1261 | this._defaultOptionGroup = void 0; |
| 1262 | } |
| 1263 | /** |
| 1264 | * Copy settings that are useful to have in common across root command and subcommands. |
| 1265 | * |
| 1266 | * (Used internally when adding a command using `.command()` so subcommands inherit parent settings.) |
| 1267 | * |
| 1268 | * @param {Command} sourceCommand |
| 1269 | * @return {Command} `this` command for chaining |
| 1270 | */ |
| 1271 | copyInheritedSettings(sourceCommand) { |
| 1272 | this._outputConfiguration = sourceCommand._outputConfiguration; |
| 1273 | this._helpOption = sourceCommand._helpOption; |
| 1274 | this._helpCommand = sourceCommand._helpCommand; |
| 1275 | this._helpConfiguration = sourceCommand._helpConfiguration; |
| 1276 | this._exitCallback = sourceCommand._exitCallback; |
| 1277 | this._storeOptionsAsProperties = sourceCommand._storeOptionsAsProperties; |
| 1278 | this._combineFlagAndOptionalValue = sourceCommand._combineFlagAndOptionalValue; |
| 1279 | this._allowExcessArguments = sourceCommand._allowExcessArguments; |
| 1280 | this._enablePositionalOptions = sourceCommand._enablePositionalOptions; |
| 1281 | this._showHelpAfterError = sourceCommand._showHelpAfterError; |
| 1282 | this._showSuggestionAfterError = sourceCommand._showSuggestionAfterError; |
| 1283 | return this; |
| 1284 | } |
| 1285 | /** |
| 1286 | * @returns {Command[]} |
| 1287 | * @private |
| 1288 | */ |
| 1289 | _getCommandAndAncestors() { |
| 1290 | const result = []; |
| 1291 | for (let command = this; command; command = command.parent) { |
| 1292 | result.push(command); |
| 1293 | } |
| 1294 | return result; |
| 1295 | } |
| 1296 | /** |
| 1297 | * Define a command. |
| 1298 | * |
| 1299 | * There are two styles of command: pay attention to where to put the description. |
| 1300 | * |
| 1301 | * @example |
| 1302 | * // Command implemented using action handler (description is supplied separately to `.command`) |
| 1303 | * program |
| 1304 | * .command('clone <source> [destination]') |
| 1305 | * .description('clone a repository into a newly created directory') |
| 1306 | * .action((source, destination) => { |
| 1307 | * console.log('clone command called'); |
| 1308 | * }); |
| 1309 | * |
| 1310 | * // Command implemented using separate executable file (description is second parameter to `.command`) |
| 1311 | * program |
| 1312 | * .command('start <service>', 'start named service') |
| 1313 | * .command('stop [service]', 'stop named service, or all if no name supplied'); |
| 1314 | * |
| 1315 | * @param {string} nameAndArgs - command name and arguments, args are `<required>` or `[optional]` and last may also be `variadic...` |
| 1316 | * @param {(object | string)} [actionOptsOrExecDesc] - configuration options (for action), or description (for executable) |
| 1317 | * @param {object} [execOpts] - configuration options (for executable) |
| 1318 | * @return {Command} returns new command for action handler, or `this` for executable command |
| 1319 | */ |
| 1320 | command(nameAndArgs, actionOptsOrExecDesc, execOpts) { |
| 1321 | let desc = actionOptsOrExecDesc; |
| 1322 | let opts = execOpts; |
| 1323 | if (typeof desc === "object" && desc !== null) { |
| 1324 | opts = desc; |
| 1325 | desc = null; |
| 1326 | } |
| 1327 | opts = opts || {}; |
| 1328 | const [, name, args] = nameAndArgs.match(/([^ ]+) *(.*)/); |
| 1329 | const cmd = this.createCommand(name); |
| 1330 | if (desc) { |
| 1331 | cmd.description(desc); |
| 1332 | cmd._executableHandler = true; |
| 1333 | } |
| 1334 | if (opts.isDefault) this._defaultCommandName = cmd._name; |
| 1335 | cmd._hidden = !!(opts.noHelp || opts.hidden); |
| 1336 | cmd._executableFile = opts.executableFile || null; |
| 1337 | if (args) cmd.arguments(args); |
| 1338 | this._registerCommand(cmd); |
| 1339 | cmd.parent = this; |
| 1340 | cmd.copyInheritedSettings(this); |
| 1341 | if (desc) return this; |
| 1342 | return cmd; |
| 1343 | } |
| 1344 | /** |
| 1345 | * Factory routine to create a new unattached command. |
| 1346 | * |
| 1347 | * See .command() for creating an attached subcommand, which uses this routine to |
| 1348 | * create the command. You can override createCommand to customise subcommands. |
| 1349 | * |
| 1350 | * @param {string} [name] |
| 1351 | * @return {Command} new command |
| 1352 | */ |
| 1353 | createCommand(name) { |
| 1354 | return new _Command(name); |
| 1355 | } |
| 1356 | /** |
| 1357 | * You can customise the help with a subclass of Help by overriding createHelp, |
| 1358 | * or by overriding Help properties using configureHelp(). |
| 1359 | * |
| 1360 | * @return {Help} |
| 1361 | */ |
| 1362 | createHelp() { |
| 1363 | return Object.assign(new Help2(), this.configureHelp()); |
| 1364 | } |
| 1365 | /** |
| 1366 | * You can customise the help by overriding Help properties using configureHelp(), |
| 1367 | * or with a subclass of Help by overriding createHelp(). |
| 1368 | * |
| 1369 | * @param {object} [configuration] - configuration options |
| 1370 | * @return {(Command | object)} `this` command for chaining, or stored configuration |
| 1371 | */ |
| 1372 | configureHelp(configuration) { |
| 1373 | if (configuration === void 0) return this._helpConfiguration; |
| 1374 | this._helpConfiguration = configuration; |
| 1375 | return this; |
| 1376 | } |
| 1377 | /** |
| 1378 | * The default output goes to stdout and stderr. You can customise this for special |
| 1379 | * applications. You can also customise the display of errors by overriding outputError. |
| 1380 | * |
| 1381 | * The configuration properties are all functions: |
| 1382 | * |
| 1383 | * // change how output being written, defaults to stdout and stderr |
| 1384 | * writeOut(str) |
| 1385 | * writeErr(str) |
| 1386 | * // change how output being written for errors, defaults to writeErr |
| 1387 | * outputError(str, write) // used for displaying errors and not used for displaying help |
| 1388 | * // specify width for wrapping help |
| 1389 | * getOutHelpWidth() |
| 1390 | * getErrHelpWidth() |
| 1391 | * // color support, currently only used with Help |
| 1392 | * getOutHasColors() |
| 1393 | * getErrHasColors() |
| 1394 | * stripColor() // used to remove ANSI escape codes if output does not have colors |
| 1395 | * |
| 1396 | * @param {object} [configuration] - configuration options |
| 1397 | * @return {(Command | object)} `this` command for chaining, or stored configuration |
| 1398 | */ |
| 1399 | configureOutput(configuration) { |
| 1400 | if (configuration === void 0) return this._outputConfiguration; |
| 1401 | this._outputConfiguration = { |
| 1402 | ...this._outputConfiguration, |
| 1403 | ...configuration |
| 1404 | }; |
| 1405 | return this; |
| 1406 | } |
| 1407 | /** |
| 1408 | * Display the help or a custom message after an error occurs. |
| 1409 | * |
| 1410 | * @param {(boolean|string)} [displayHelp] |
| 1411 | * @return {Command} `this` command for chaining |
| 1412 | */ |
| 1413 | showHelpAfterError(displayHelp = true) { |
| 1414 | if (typeof displayHelp !== "string") displayHelp = !!displayHelp; |
| 1415 | this._showHelpAfterError = displayHelp; |
| 1416 | return this; |
| 1417 | } |
| 1418 | /** |
| 1419 | * Display suggestion of similar commands for unknown commands, or options for unknown options. |
| 1420 | * |
| 1421 | * @param {boolean} [displaySuggestion] |
| 1422 | * @return {Command} `this` command for chaining |
| 1423 | */ |
| 1424 | showSuggestionAfterError(displaySuggestion = true) { |
| 1425 | this._showSuggestionAfterError = !!displaySuggestion; |
| 1426 | return this; |
| 1427 | } |
| 1428 | /** |
| 1429 | * Add a prepared subcommand. |
| 1430 | * |
| 1431 | * See .command() for creating an attached subcommand which inherits settings from its parent. |
| 1432 | * |
| 1433 | * @param {Command} cmd - new subcommand |
| 1434 | * @param {object} [opts] - configuration options |
| 1435 | * @return {Command} `this` command for chaining |
| 1436 | */ |
| 1437 | addCommand(cmd, opts) { |
| 1438 | if (!cmd._name) { |
| 1439 | throw new Error(`Command passed to .addCommand() must have a name |
| 1440 | - specify the name in Command constructor or using .name()`); |
| 1441 | } |
| 1442 | opts = opts || {}; |
| 1443 | if (opts.isDefault) this._defaultCommandName = cmd._name; |
| 1444 | if (opts.noHelp || opts.hidden) cmd._hidden = true; |
| 1445 | this._registerCommand(cmd); |
| 1446 | cmd.parent = this; |
| 1447 | cmd._checkForBrokenPassThrough(); |
| 1448 | return this; |
| 1449 | } |
| 1450 | /** |
| 1451 | * Factory routine to create a new unattached argument. |
| 1452 | * |
| 1453 | * See .argument() for creating an attached argument, which uses this routine to |
| 1454 | * create the argument. You can override createArgument to return a custom argument. |
| 1455 | * |
| 1456 | * @param {string} name |
| 1457 | * @param {string} [description] |
| 1458 | * @return {Argument} new argument |
| 1459 | */ |
| 1460 | createArgument(name, description) { |
| 1461 | return new Argument2(name, description); |
| 1462 | } |
| 1463 | /** |
| 1464 | * Define argument syntax for command. |
| 1465 | * |
| 1466 | * The default is that the argument is required, and you can explicitly |
| 1467 | * indicate this with <> around the name. Put [] around the name for an optional argument. |
| 1468 | * |
| 1469 | * @example |
| 1470 | * program.argument('<input-file>'); |
| 1471 | * program.argument('[output-file]'); |
| 1472 | * |
| 1473 | * @param {string} name |
| 1474 | * @param {string} [description] |
| 1475 | * @param {(Function|*)} [parseArg] - custom argument processing function or default value |
| 1476 | * @param {*} [defaultValue] |
| 1477 | * @return {Command} `this` command for chaining |
| 1478 | */ |
| 1479 | argument(name, description, parseArg, defaultValue) { |
| 1480 | const argument = this.createArgument(name, description); |
| 1481 | if (typeof parseArg === "function") { |
| 1482 | argument.default(defaultValue).argParser(parseArg); |
| 1483 | } else { |
| 1484 | argument.default(parseArg); |
| 1485 | } |
| 1486 | this.addArgument(argument); |
| 1487 | return this; |
| 1488 | } |
| 1489 | /** |
| 1490 | * Define argument syntax for command, adding multiple at once (without descriptions). |
| 1491 | * |
| 1492 | * See also .argument(). |
| 1493 | * |
| 1494 | * @example |
| 1495 | * program.arguments('<cmd> [env]'); |
| 1496 | * |
| 1497 | * @param {string} names |
| 1498 | * @return {Command} `this` command for chaining |
| 1499 | */ |
| 1500 | arguments(names) { |
| 1501 | names.trim().split(/ +/).forEach((detail) => { |
| 1502 | this.argument(detail); |
| 1503 | }); |
| 1504 | return this; |
| 1505 | } |
| 1506 | /** |
| 1507 | * Define argument syntax for command, adding a prepared argument. |
| 1508 | * |
| 1509 | * @param {Argument} argument |
| 1510 | * @return {Command} `this` command for chaining |
| 1511 | */ |
| 1512 | addArgument(argument) { |
| 1513 | const previousArgument = this.registeredArguments.slice(-1)[0]; |
| 1514 | if (previousArgument?.variadic) { |
| 1515 | throw new Error( |
| 1516 | `only the last argument can be variadic '${previousArgument.name()}'` |
| 1517 | ); |
| 1518 | } |
| 1519 | if (argument.required && argument.defaultValue !== void 0 && argument.parseArg === void 0) { |
| 1520 | throw new Error( |
| 1521 | `a default value for a required argument is never used: '${argument.name()}'` |
| 1522 | ); |
| 1523 | } |
| 1524 | this.registeredArguments.push(argument); |
| 1525 | return this; |
| 1526 | } |
| 1527 | /** |
| 1528 | * Customise or override default help command. By default a help command is automatically added if your command has subcommands. |
| 1529 | * |
| 1530 | * @example |
| 1531 | * program.helpCommand('help [cmd]'); |
| 1532 | * program.helpCommand('help [cmd]', 'show help'); |
| 1533 | * program.helpCommand(false); // suppress default help command |
| 1534 | * program.helpCommand(true); // add help command even if no subcommands |
| 1535 | * |
| 1536 | * @param {string|boolean} enableOrNameAndArgs - enable with custom name and/or arguments, or boolean to override whether added |
| 1537 | * @param {string} [description] - custom description |
| 1538 | * @return {Command} `this` command for chaining |
| 1539 | */ |
| 1540 | helpCommand(enableOrNameAndArgs, description) { |
| 1541 | if (typeof enableOrNameAndArgs === "boolean") { |
| 1542 | this._addImplicitHelpCommand = enableOrNameAndArgs; |
| 1543 | if (enableOrNameAndArgs && this._defaultCommandGroup) { |
| 1544 | this._initCommandGroup(this._getHelpCommand()); |
| 1545 | } |
| 1546 | return this; |
| 1547 | } |
| 1548 | const nameAndArgs = enableOrNameAndArgs ?? "help [command]"; |
| 1549 | const [, helpName, helpArgs] = nameAndArgs.match(/([^ ]+) *(.*)/); |
| 1550 | const helpDescription = description ?? "display help for command"; |
| 1551 | const helpCommand = this.createCommand(helpName); |
| 1552 | helpCommand.helpOption(false); |
| 1553 | if (helpArgs) helpCommand.arguments(helpArgs); |
| 1554 | if (helpDescription) helpCommand.description(helpDescription); |
| 1555 | this._addImplicitHelpCommand = true; |
| 1556 | this._helpCommand = helpCommand; |
| 1557 | if (enableOrNameAndArgs || description) this._initCommandGroup(helpCommand); |
| 1558 | return this; |
| 1559 | } |
| 1560 | /** |
| 1561 | * Add prepared custom help command. |
| 1562 | * |
| 1563 | * @param {(Command|string|boolean)} helpCommand - custom help command, or deprecated enableOrNameAndArgs as for `.helpCommand()` |
| 1564 | * @param {string} [deprecatedDescription] - deprecated custom description used with custom name only |
| 1565 | * @return {Command} `this` command for chaining |
| 1566 | */ |
| 1567 | addHelpCommand(helpCommand, deprecatedDescription) { |
| 1568 | if (typeof helpCommand !== "object") { |
| 1569 | this.helpCommand(helpCommand, deprecatedDescription); |
| 1570 | return this; |
| 1571 | } |
| 1572 | this._addImplicitHelpCommand = true; |
| 1573 | this._helpCommand = helpCommand; |
| 1574 | this._initCommandGroup(helpCommand); |
| 1575 | return this; |
| 1576 | } |
| 1577 | /** |
| 1578 | * Lazy create help command. |
| 1579 | * |
| 1580 | * @return {(Command|null)} |
| 1581 | * @package |
| 1582 | */ |
| 1583 | _getHelpCommand() { |
| 1584 | const hasImplicitHelpCommand = this._addImplicitHelpCommand ?? (this.commands.length && !this._actionHandler && !this._findCommand("help")); |
| 1585 | if (hasImplicitHelpCommand) { |
| 1586 | if (this._helpCommand === void 0) { |
| 1587 | this.helpCommand(void 0, void 0); |
| 1588 | } |
| 1589 | return this._helpCommand; |
| 1590 | } |
| 1591 | return null; |
| 1592 | } |
| 1593 | /** |
| 1594 | * Add hook for life cycle event. |
| 1595 | * |
| 1596 | * @param {string} event |
| 1597 | * @param {Function} listener |
| 1598 | * @return {Command} `this` command for chaining |
| 1599 | */ |
| 1600 | hook(event, listener) { |
| 1601 | const allowedValues = ["preSubcommand", "preAction", "postAction"]; |
| 1602 | if (!allowedValues.includes(event)) { |
| 1603 | throw new Error(`Unexpected value for event passed to hook : '${event}'. |
| 1604 | Expecting one of '${allowedValues.join("', '")}'`); |
| 1605 | } |
| 1606 | if (this._lifeCycleHooks[event]) { |
| 1607 | this._lifeCycleHooks[event].push(listener); |
| 1608 | } else { |
| 1609 | this._lifeCycleHooks[event] = [listener]; |
| 1610 | } |
| 1611 | return this; |
| 1612 | } |
| 1613 | /** |
| 1614 | * Register callback to use as replacement for calling process.exit. |
| 1615 | * |
| 1616 | * @param {Function} [fn] optional callback which will be passed a CommanderError, defaults to throwing |
| 1617 | * @return {Command} `this` command for chaining |
| 1618 | */ |
| 1619 | exitOverride(fn) { |
| 1620 | if (fn) { |
| 1621 | this._exitCallback = fn; |
| 1622 | } else { |
| 1623 | this._exitCallback = (err) => { |
| 1624 | if (err.code !== "commander.executeSubCommandAsync") { |
| 1625 | throw err; |
| 1626 | } else { |
| 1627 | } |
| 1628 | }; |
| 1629 | } |
| 1630 | return this; |
| 1631 | } |
| 1632 | /** |
| 1633 | * Call process.exit, and _exitCallback if defined. |
| 1634 | * |
| 1635 | * @param {number} exitCode exit code for using with process.exit |
| 1636 | * @param {string} code an id string representing the error |
| 1637 | * @param {string} message human-readable description of the error |
| 1638 | * @return never |
| 1639 | * @private |
| 1640 | */ |
| 1641 | _exit(exitCode, code, message) { |
| 1642 | if (this._exitCallback) { |
| 1643 | this._exitCallback(new CommanderError2(exitCode, code, message)); |
| 1644 | } |
| 1645 | process2.exit(exitCode); |
| 1646 | } |
| 1647 | /** |
| 1648 | * Register callback `fn` for the command. |
| 1649 | * |
| 1650 | * @example |
| 1651 | * program |
| 1652 | * .command('serve') |
| 1653 | * .description('start service') |
| 1654 | * .action(function() { |
| 1655 | * // do work here |
| 1656 | * }); |
| 1657 | * |
| 1658 | * @param {Function} fn |
| 1659 | * @return {Command} `this` command for chaining |
| 1660 | */ |
| 1661 | action(fn) { |
| 1662 | const listener = (args) => { |
| 1663 | const expectedArgsCount = this.registeredArguments.length; |
| 1664 | const actionArgs = args.slice(0, expectedArgsCount); |
| 1665 | if (this._storeOptionsAsProperties) { |
| 1666 | actionArgs[expectedArgsCount] = this; |
| 1667 | } else { |
| 1668 | actionArgs[expectedArgsCount] = this.opts(); |
| 1669 | } |
| 1670 | actionArgs.push(this); |
| 1671 | return fn.apply(this, actionArgs); |
| 1672 | }; |
| 1673 | this._actionHandler = listener; |
| 1674 | return this; |
| 1675 | } |
| 1676 | /** |
| 1677 | * Factory routine to create a new unattached option. |
| 1678 | * |
| 1679 | * See .option() for creating an attached option, which uses this routine to |
| 1680 | * create the option. You can override createOption to return a custom option. |
| 1681 | * |
| 1682 | * @param {string} flags |
| 1683 | * @param {string} [description] |
| 1684 | * @return {Option} new option |
| 1685 | */ |
| 1686 | createOption(flags, description) { |
| 1687 | return new Option2(flags, description); |
| 1688 | } |
| 1689 | /** |
| 1690 | * Wrap parseArgs to catch 'commander.invalidArgument'. |
| 1691 | * |
| 1692 | * @param {(Option | Argument)} target |
| 1693 | * @param {string} value |
| 1694 | * @param {*} previous |
| 1695 | * @param {string} invalidArgumentMessage |
| 1696 | * @private |
| 1697 | */ |
| 1698 | _callParseArg(target, value, previous, invalidArgumentMessage) { |
| 1699 | try { |
| 1700 | return target.parseArg(value, previous); |
| 1701 | } catch (err) { |
| 1702 | if (err.code === "commander.invalidArgument") { |
| 1703 | const message = `${invalidArgumentMessage} ${err.message}`; |
| 1704 | this.error(message, { exitCode: err.exitCode, code: err.code }); |
| 1705 | } |
| 1706 | throw err; |
| 1707 | } |
| 1708 | } |
| 1709 | /** |
| 1710 | * Check for option flag conflicts. |
| 1711 | * Register option if no conflicts found, or throw on conflict. |
| 1712 | * |
| 1713 | * @param {Option} option |
| 1714 | * @private |
| 1715 | */ |
| 1716 | _registerOption(option) { |
| 1717 | const matchingOption = option.short && this._findOption(option.short) || option.long && this._findOption(option.long); |
| 1718 | if (matchingOption) { |
| 1719 | const matchingFlag = option.long && this._findOption(option.long) ? option.long : option.short; |
| 1720 | throw new Error(`Cannot add option '${option.flags}'${this._name && ` to command '${this._name}'`} due to conflicting flag '${matchingFlag}' |
| 1721 | - already used by option '${matchingOption.flags}'`); |
| 1722 | } |
| 1723 | this._initOptionGroup(option); |
| 1724 | this.options.push(option); |
| 1725 | } |
| 1726 | /** |
| 1727 | * Check for command name and alias conflicts with existing commands. |
| 1728 | * Register command if no conflicts found, or throw on conflict. |
| 1729 | * |
| 1730 | * @param {Command} command |
| 1731 | * @private |
| 1732 | */ |
| 1733 | _registerCommand(command) { |
| 1734 | const knownBy = (cmd) => { |
| 1735 | return [cmd.name()].concat(cmd.aliases()); |
| 1736 | }; |
| 1737 | const alreadyUsed = knownBy(command).find( |
| 1738 | (name) => this._findCommand(name) |
| 1739 | ); |
| 1740 | if (alreadyUsed) { |
| 1741 | const existingCmd = knownBy(this._findCommand(alreadyUsed)).join("|"); |
| 1742 | const newCmd = knownBy(command).join("|"); |
| 1743 | throw new Error( |
| 1744 | `cannot add command '${newCmd}' as already have command '${existingCmd}'` |
| 1745 | ); |
| 1746 | } |
| 1747 | this._initCommandGroup(command); |
| 1748 | this.commands.push(command); |
| 1749 | } |
| 1750 | /** |
| 1751 | * Add an option. |
| 1752 | * |
| 1753 | * @param {Option} option |
| 1754 | * @return {Command} `this` command for chaining |
| 1755 | */ |
| 1756 | addOption(option) { |
| 1757 | this._registerOption(option); |
| 1758 | const oname = option.name(); |
| 1759 | const name = option.attributeName(); |
| 1760 | if (option.negate) { |
| 1761 | const positiveLongFlag = option.long.replace(/^--no-/, "--"); |
| 1762 | if (!this._findOption(positiveLongFlag)) { |
| 1763 | this.setOptionValueWithSource( |
| 1764 | name, |
| 1765 | option.defaultValue === void 0 ? true : option.defaultValue, |
| 1766 | "default" |
| 1767 | ); |
| 1768 | } |
| 1769 | } else if (option.defaultValue !== void 0) { |
| 1770 | this.setOptionValueWithSource(name, option.defaultValue, "default"); |
| 1771 | } |
| 1772 | const handleOptionValue = (val, invalidValueMessage, valueSource) => { |
| 1773 | if (val == null && option.presetArg !== void 0) { |
| 1774 | val = option.presetArg; |
| 1775 | } |
| 1776 | const oldValue = this.getOptionValue(name); |
| 1777 | if (val !== null && option.parseArg) { |
| 1778 | val = this._callParseArg(option, val, oldValue, invalidValueMessage); |
| 1779 | } else if (val !== null && option.variadic) { |
| 1780 | val = option._collectValue(val, oldValue); |
| 1781 | } |
| 1782 | if (val == null) { |
| 1783 | if (option.negate) { |
| 1784 | val = false; |
| 1785 | } else if (option.isBoolean() || option.optional) { |
| 1786 | val = true; |
| 1787 | } else { |
| 1788 | val = ""; |
| 1789 | } |
| 1790 | } |
| 1791 | this.setOptionValueWithSource(name, val, valueSource); |
| 1792 | }; |
| 1793 | this.on("option:" + oname, (val) => { |
| 1794 | const invalidValueMessage = `error: option '${option.flags}' argument '${val}' is invalid.`; |
| 1795 | handleOptionValue(val, invalidValueMessage, "cli"); |
| 1796 | }); |
| 1797 | if (option.envVar) { |
| 1798 | this.on("optionEnv:" + oname, (val) => { |
| 1799 | const invalidValueMessage = `error: option '${option.flags}' value '${val}' from env '${option.envVar}' is invalid.`; |
| 1800 | handleOptionValue(val, invalidValueMessage, "env"); |
| 1801 | }); |
| 1802 | } |
| 1803 | return this; |
| 1804 | } |
| 1805 | /** |
| 1806 | * Internal implementation shared by .option() and .requiredOption() |
| 1807 | * |
| 1808 | * @return {Command} `this` command for chaining |
| 1809 | * @private |
| 1810 | */ |
| 1811 | _optionEx(config, flags, description, fn, defaultValue) { |
| 1812 | if (typeof flags === "object" && flags instanceof Option2) { |
| 1813 | throw new Error( |
| 1814 | "To add an Option object use addOption() instead of option() or requiredOption()" |
| 1815 | ); |
| 1816 | } |
| 1817 | const option = this.createOption(flags, description); |
| 1818 | option.makeOptionMandatory(!!config.mandatory); |
| 1819 | if (typeof fn === "function") { |
| 1820 | option.default(defaultValue).argParser(fn); |
| 1821 | } else if (fn instanceof RegExp) { |
| 1822 | const regex = fn; |
| 1823 | fn = (val, def) => { |
| 1824 | const m = regex.exec(val); |
| 1825 | return m ? m[0] : def; |
| 1826 | }; |
| 1827 | option.default(defaultValue).argParser(fn); |
| 1828 | } else { |
| 1829 | option.default(fn); |
| 1830 | } |
| 1831 | return this.addOption(option); |
| 1832 | } |
| 1833 | /** |
| 1834 | * Define option with `flags`, `description`, and optional argument parsing function or `defaultValue` or both. |
| 1835 | * |
| 1836 | * The `flags` string contains the short and/or long flags, separated by comma, a pipe or space. A required |
| 1837 | * option-argument is indicated by `<>` and an optional option-argument by `[]`. |
| 1838 | * |
| 1839 | * See the README for more details, and see also addOption() and requiredOption(). |
| 1840 | * |
| 1841 | * @example |
| 1842 | * program |
| 1843 | * .option('-p, --pepper', 'add pepper') |
| 1844 | * .option('--pt, --pizza-type <TYPE>', 'type of pizza') // required option-argument |
| 1845 | * .option('-c, --cheese [CHEESE]', 'add extra cheese', 'mozzarella') // optional option-argument with default |
| 1846 | * .option('-t, --tip <VALUE>', 'add tip to purchase cost', parseFloat) // custom parse function |
| 1847 | * |
| 1848 | * @param {string} flags |
| 1849 | * @param {string} [description] |
| 1850 | * @param {(Function|*)} [parseArg] - custom option processing function or default value |
| 1851 | * @param {*} [defaultValue] |
| 1852 | * @return {Command} `this` command for chaining |
| 1853 | */ |
| 1854 | option(flags, description, parseArg, defaultValue) { |
| 1855 | return this._optionEx({}, flags, description, parseArg, defaultValue); |
| 1856 | } |
| 1857 | /** |
| 1858 | * Add a required option which must have a value after parsing. This usually means |
| 1859 | * the option must be specified on the command line. (Otherwise the same as .option().) |
| 1860 | * |
| 1861 | * The `flags` string contains the short and/or long flags, separated by comma, a pipe or space. |
| 1862 | * |
| 1863 | * @param {string} flags |
| 1864 | * @param {string} [description] |
| 1865 | * @param {(Function|*)} [parseArg] - custom option processing function or default value |
| 1866 | * @param {*} [defaultValue] |
| 1867 | * @return {Command} `this` command for chaining |
| 1868 | */ |
| 1869 | requiredOption(flags, description, parseArg, defaultValue) { |
| 1870 | return this._optionEx( |
| 1871 | { mandatory: true }, |
| 1872 | flags, |
| 1873 | description, |
| 1874 | parseArg, |
| 1875 | defaultValue |
| 1876 | ); |
| 1877 | } |
| 1878 | /** |
| 1879 | * Alter parsing of short flags with optional values. |
| 1880 | * |
| 1881 | * @example |
| 1882 | * // for `.option('-f,--flag [value]'): |
| 1883 | * program.combineFlagAndOptionalValue(true); // `-f80` is treated like `--flag=80`, this is the default behaviour |
| 1884 | * program.combineFlagAndOptionalValue(false) // `-fb` is treated like `-f -b` |
| 1885 | * |
| 1886 | * @param {boolean} [combine] - if `true` or omitted, an optional value can be specified directly after the flag. |
| 1887 | * @return {Command} `this` command for chaining |
| 1888 | */ |
| 1889 | combineFlagAndOptionalValue(combine = true) { |
| 1890 | this._combineFlagAndOptionalValue = !!combine; |
| 1891 | return this; |
| 1892 | } |
| 1893 | /** |
| 1894 | * Allow unknown options on the command line. |
| 1895 | * |
| 1896 | * @param {boolean} [allowUnknown] - if `true` or omitted, no error will be thrown for unknown options. |
| 1897 | * @return {Command} `this` command for chaining |
| 1898 | */ |
| 1899 | allowUnknownOption(allowUnknown = true) { |
| 1900 | this._allowUnknownOption = !!allowUnknown; |
| 1901 | return this; |
| 1902 | } |
| 1903 | /** |
| 1904 | * Allow excess command-arguments on the command line. Pass false to make excess arguments an error. |
| 1905 | * |
| 1906 | * @param {boolean} [allowExcess] - if `true` or omitted, no error will be thrown for excess arguments. |
| 1907 | * @return {Command} `this` command for chaining |
| 1908 | */ |
| 1909 | allowExcessArguments(allowExcess = true) { |
| 1910 | this._allowExcessArguments = !!allowExcess; |
| 1911 | return this; |
| 1912 | } |
| 1913 | /** |
| 1914 | * Enable positional options. Positional means global options are specified before subcommands which lets |
| 1915 | * subcommands reuse the same option names, and also enables subcommands to turn on passThroughOptions. |
| 1916 | * The default behaviour is non-positional and global options may appear anywhere on the command line. |
| 1917 | * |
| 1918 | * @param {boolean} [positional] |
| 1919 | * @return {Command} `this` command for chaining |
| 1920 | */ |
| 1921 | enablePositionalOptions(positional = true) { |
| 1922 | this._enablePositionalOptions = !!positional; |
| 1923 | return this; |
| 1924 | } |
| 1925 | /** |
| 1926 | * Pass through options that come after command-arguments rather than treat them as command-options, |
| 1927 | * so actual command-options come before command-arguments. Turning this on for a subcommand requires |
| 1928 | * positional options to have been enabled on the program (parent commands). |
| 1929 | * The default behaviour is non-positional and options may appear before or after command-arguments. |
| 1930 | * |
| 1931 | * @param {boolean} [passThrough] for unknown options. |
| 1932 | * @return {Command} `this` command for chaining |
| 1933 | */ |
| 1934 | passThroughOptions(passThrough = true) { |
| 1935 | this._passThroughOptions = !!passThrough; |
| 1936 | this._checkForBrokenPassThrough(); |
| 1937 | return this; |
| 1938 | } |
| 1939 | /** |
| 1940 | * @private |
| 1941 | */ |
| 1942 | _checkForBrokenPassThrough() { |
| 1943 | if (this.parent && this._passThroughOptions && !this.parent._enablePositionalOptions) { |
| 1944 | throw new Error( |
| 1945 | `passThroughOptions cannot be used for '${this._name}' without turning on enablePositionalOptions for parent command(s)` |
| 1946 | ); |
| 1947 | } |
| 1948 | } |
| 1949 | /** |
| 1950 | * Whether to store option values as properties on command object, |
| 1951 | * or store separately (specify false). In both cases the option values can be accessed using .opts(). |
| 1952 | * |
| 1953 | * @param {boolean} [storeAsProperties=true] |
| 1954 | * @return {Command} `this` command for chaining |
| 1955 | */ |
| 1956 | storeOptionsAsProperties(storeAsProperties = true) { |
| 1957 | if (this.options.length) { |
| 1958 | throw new Error("call .storeOptionsAsProperties() before adding options"); |
| 1959 | } |
| 1960 | if (Object.keys(this._optionValues).length) { |
| 1961 | throw new Error( |
| 1962 | "call .storeOptionsAsProperties() before setting option values" |
| 1963 | ); |
| 1964 | } |
| 1965 | this._storeOptionsAsProperties = !!storeAsProperties; |
| 1966 | return this; |
| 1967 | } |
| 1968 | /** |
| 1969 | * Retrieve option value. |
| 1970 | * |
| 1971 | * @param {string} key |
| 1972 | * @return {object} value |
| 1973 | */ |
| 1974 | getOptionValue(key) { |
| 1975 | if (this._storeOptionsAsProperties) { |
| 1976 | return this[key]; |
| 1977 | } |
| 1978 | return this._optionValues[key]; |
| 1979 | } |
| 1980 | /** |
| 1981 | * Store option value. |
| 1982 | * |
| 1983 | * @param {string} key |
| 1984 | * @param {object} value |
| 1985 | * @return {Command} `this` command for chaining |
| 1986 | */ |
| 1987 | setOptionValue(key, value) { |
| 1988 | return this.setOptionValueWithSource(key, value, void 0); |
| 1989 | } |
| 1990 | /** |
| 1991 | * Store option value and where the value came from. |
| 1992 | * |
| 1993 | * @param {string} key |
| 1994 | * @param {object} value |
| 1995 | * @param {string} source - expected values are default/config/env/cli/implied |
| 1996 | * @return {Command} `this` command for chaining |
| 1997 | */ |
| 1998 | setOptionValueWithSource(key, value, source) { |
| 1999 | if (this._storeOptionsAsProperties) { |
| 2000 | this[key] = value; |
| 2001 | } else { |
| 2002 | this._optionValues[key] = value; |
| 2003 | } |
| 2004 | this._optionValueSources[key] = source; |
| 2005 | return this; |
| 2006 | } |
| 2007 | /** |
| 2008 | * Get source of option value. |
| 2009 | * Expected values are default | config | env | cli | implied |
| 2010 | * |
| 2011 | * @param {string} key |
| 2012 | * @return {string} |
| 2013 | */ |
| 2014 | getOptionValueSource(key) { |
| 2015 | return this._optionValueSources[key]; |
| 2016 | } |
| 2017 | /** |
| 2018 | * Get source of option value. See also .optsWithGlobals(). |
| 2019 | * Expected values are default | config | env | cli | implied |
| 2020 | * |
| 2021 | * @param {string} key |
| 2022 | * @return {string} |
| 2023 | */ |
| 2024 | getOptionValueSourceWithGlobals(key) { |
| 2025 | let source; |
| 2026 | this._getCommandAndAncestors().forEach((cmd) => { |
| 2027 | if (cmd.getOptionValueSource(key) !== void 0) { |
| 2028 | source = cmd.getOptionValueSource(key); |
| 2029 | } |
| 2030 | }); |
| 2031 | return source; |
| 2032 | } |
| 2033 | /** |
| 2034 | * Get user arguments from implied or explicit arguments. |
| 2035 | * Side-effects: set _scriptPath if args included script. Used for default program name, and subcommand searches. |
| 2036 | * |
| 2037 | * @private |
| 2038 | */ |
| 2039 | _prepareUserArgs(argv, parseOptions) { |
| 2040 | if (argv !== void 0 && !Array.isArray(argv)) { |
| 2041 | throw new Error("first parameter to parse must be array or undefined"); |
| 2042 | } |
| 2043 | parseOptions = parseOptions || {}; |
| 2044 | if (argv === void 0 && parseOptions.from === void 0) { |
| 2045 | if (process2.versions?.electron) { |
| 2046 | parseOptions.from = "electron"; |
| 2047 | } |
| 2048 | const execArgv = process2.execArgv ?? []; |
| 2049 | if (execArgv.includes("-e") || execArgv.includes("--eval") || execArgv.includes("-p") || execArgv.includes("--print")) { |
| 2050 | parseOptions.from = "eval"; |
| 2051 | } |
| 2052 | } |
| 2053 | if (argv === void 0) { |
| 2054 | argv = process2.argv; |
| 2055 | } |
| 2056 | this.rawArgs = argv.slice(); |
| 2057 | let userArgs; |
| 2058 | switch (parseOptions.from) { |
| 2059 | case void 0: |
| 2060 | case "node": |
| 2061 | this._scriptPath = argv[1]; |
| 2062 | userArgs = argv.slice(2); |
| 2063 | break; |
| 2064 | case "electron": |
| 2065 | if (process2.defaultApp) { |
| 2066 | this._scriptPath = argv[1]; |
| 2067 | userArgs = argv.slice(2); |
| 2068 | } else { |
| 2069 | userArgs = argv.slice(1); |
| 2070 | } |
| 2071 | break; |
| 2072 | case "user": |
| 2073 | userArgs = argv.slice(0); |
| 2074 | break; |
| 2075 | case "eval": |
| 2076 | userArgs = argv.slice(1); |
| 2077 | break; |
| 2078 | default: |
| 2079 | throw new Error( |
| 2080 | `unexpected parse option { from: '${parseOptions.from}' }` |
| 2081 | ); |
| 2082 | } |
| 2083 | if (!this._name && this._scriptPath) |
| 2084 | this.nameFromFilename(this._scriptPath); |
| 2085 | this._name = this._name || "program"; |
| 2086 | return userArgs; |
| 2087 | } |
| 2088 | /** |
| 2089 | * Parse `argv`, setting options and invoking commands when defined. |
| 2090 | * |
| 2091 | * Use parseAsync instead of parse if any of your action handlers are async. |
| 2092 | * |
| 2093 | * Call with no parameters to parse `process.argv`. Detects Electron and special node options like `node --eval`. Easy mode! |
| 2094 | * |
| 2095 | * Or call with an array of strings to parse, and optionally where the user arguments start by specifying where the arguments are `from`: |
| 2096 | * - `'node'`: default, `argv[0]` is the application and `argv[1]` is the script being run, with user arguments after that |
| 2097 | * - `'electron'`: `argv[0]` is the application and `argv[1]` varies depending on whether the electron application is packaged |
| 2098 | * - `'user'`: just user arguments |
| 2099 | * |
| 2100 | * @example |
| 2101 | * program.parse(); // parse process.argv and auto-detect electron and special node flags |
| 2102 | * program.parse(process.argv); // assume argv[0] is app and argv[1] is script |
| 2103 | * program.parse(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0] |
| 2104 | * |
| 2105 | * @param {string[]} [argv] - optional, defaults to process.argv |
| 2106 | * @param {object} [parseOptions] - optionally specify style of options with from: node/user/electron |
| 2107 | * @param {string} [parseOptions.from] - where the args are from: 'node', 'user', 'electron' |
| 2108 | * @return {Command} `this` command for chaining |
| 2109 | */ |
| 2110 | parse(argv, parseOptions) { |
| 2111 | this._prepareForParse(); |
| 2112 | const userArgs = this._prepareUserArgs(argv, parseOptions); |
| 2113 | this._parseCommand([], userArgs); |
| 2114 | return this; |
| 2115 | } |
| 2116 | /** |
| 2117 | * Parse `argv`, setting options and invoking commands when defined. |
| 2118 | * |
| 2119 | * Call with no parameters to parse `process.argv`. Detects Electron and special node options like `node --eval`. Easy mode! |
| 2120 | * |
| 2121 | * Or call with an array of strings to parse, and optionally where the user arguments start by specifying where the arguments are `from`: |
| 2122 | * - `'node'`: default, `argv[0]` is the application and `argv[1]` is the script being run, with user arguments after that |
| 2123 | * - `'electron'`: `argv[0]` is the application and `argv[1]` varies depending on whether the electron application is packaged |
| 2124 | * - `'user'`: just user arguments |
| 2125 | * |
| 2126 | * @example |
| 2127 | * await program.parseAsync(); // parse process.argv and auto-detect electron and special node flags |
| 2128 | * await program.parseAsync(process.argv); // assume argv[0] is app and argv[1] is script |
| 2129 | * await program.parseAsync(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0] |
| 2130 | * |
| 2131 | * @param {string[]} [argv] |
| 2132 | * @param {object} [parseOptions] |
| 2133 | * @param {string} parseOptions.from - where the args are from: 'node', 'user', 'electron' |
| 2134 | * @return {Promise} |
| 2135 | */ |
| 2136 | async parseAsync(argv, parseOptions) { |
| 2137 | this._prepareForParse(); |
| 2138 | const userArgs = this._prepareUserArgs(argv, parseOptions); |
| 2139 | await this._parseCommand([], userArgs); |
| 2140 | return this; |
| 2141 | } |
| 2142 | _prepareForParse() { |
| 2143 | if (this._savedState === null) { |
| 2144 | this.saveStateBeforeParse(); |
| 2145 | } else { |
| 2146 | this.restoreStateBeforeParse(); |
| 2147 | } |
| 2148 | } |
| 2149 | /** |
| 2150 | * Called the first time parse is called to save state and allow a restore before subsequent calls to parse. |
| 2151 | * Not usually called directly, but available for subclasses to save their custom state. |
| 2152 | * |
| 2153 | * This is called in a lazy way. Only commands used in parsing chain will have state saved. |
| 2154 | */ |
| 2155 | saveStateBeforeParse() { |
| 2156 | this._savedState = { |
| 2157 | // name is stable if supplied by author, but may be unspecified for root command and deduced during parsing |
| 2158 | _name: this._name, |
| 2159 | // option values before parse have default values (including false for negated options) |
| 2160 | // shallow clones |
| 2161 | _optionValues: { ...this._optionValues }, |
| 2162 | _optionValueSources: { ...this._optionValueSources } |
| 2163 | }; |
| 2164 | } |
| 2165 | /** |
| 2166 | * Restore state before parse for calls after the first. |
| 2167 | * Not usually called directly, but available for subclasses to save their custom state. |
| 2168 | * |
| 2169 | * This is called in a lazy way. Only commands used in parsing chain will have state restored. |
| 2170 | */ |
| 2171 | restoreStateBeforeParse() { |
| 2172 | if (this._storeOptionsAsProperties) |
| 2173 | throw new Error(`Can not call parse again when storeOptionsAsProperties is true. |
| 2174 | - either make a new Command for each call to parse, or stop storing options as properties`); |
| 2175 | this._name = this._savedState._name; |
| 2176 | this._scriptPath = null; |
| 2177 | this.rawArgs = []; |
| 2178 | this._optionValues = { ...this._savedState._optionValues }; |
| 2179 | this._optionValueSources = { ...this._savedState._optionValueSources }; |
| 2180 | this.args = []; |
| 2181 | this.processedArgs = []; |
| 2182 | } |
| 2183 | /** |
| 2184 | * Throw if expected executable is missing. Add lots of help for author. |
| 2185 | * |
| 2186 | * @param {string} executableFile |
| 2187 | * @param {string} executableDir |
| 2188 | * @param {string} subcommandName |
| 2189 | */ |
| 2190 | _checkForMissingExecutable(executableFile, executableDir, subcommandName) { |
| 2191 | if (fs5.existsSync(executableFile)) return; |
| 2192 | const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory"; |
| 2193 | const executableMissing = `'${executableFile}' does not exist |
| 2194 | - if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead |
| 2195 | - if the default executable name is not suitable, use the executableFile option to supply a custom name or path |
| 2196 | - ${executableDirMessage}`; |
| 2197 | throw new Error(executableMissing); |
| 2198 | } |
| 2199 | /** |
| 2200 | * Execute a sub-command executable. |
| 2201 | * |
| 2202 | * @private |
| 2203 | */ |
| 2204 | _executeSubCommand(subcommand, args) { |
| 2205 | args = args.slice(); |
| 2206 | let launchWithNode = false; |
| 2207 | const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"]; |
| 2208 | function findFile(baseDir, baseName) { |
| 2209 | const localBin = path5.resolve(baseDir, baseName); |
| 2210 | if (fs5.existsSync(localBin)) return localBin; |
| 2211 | if (sourceExt.includes(path5.extname(baseName))) return void 0; |
| 2212 | const foundExt = sourceExt.find( |
| 2213 | (ext) => fs5.existsSync(`${localBin}${ext}`) |
| 2214 | ); |
| 2215 | if (foundExt) return `${localBin}${foundExt}`; |
| 2216 | return void 0; |
| 2217 | } |
| 2218 | this._checkForMissingMandatoryOptions(); |
| 2219 | this._checkForConflictingOptions(); |
| 2220 | let executableFile = subcommand._executableFile || `${this._name}-${subcommand._name}`; |
| 2221 | let executableDir = this._executableDir || ""; |
| 2222 | if (this._scriptPath) { |
| 2223 | let resolvedScriptPath; |
| 2224 | try { |
| 2225 | resolvedScriptPath = fs5.realpathSync(this._scriptPath); |
| 2226 | } catch { |
| 2227 | resolvedScriptPath = this._scriptPath; |
| 2228 | } |
| 2229 | executableDir = path5.resolve( |
| 2230 | path5.dirname(resolvedScriptPath), |
| 2231 | executableDir |
| 2232 | ); |
| 2233 | } |
| 2234 | if (executableDir) { |
| 2235 | let localFile = findFile(executableDir, executableFile); |
| 2236 | if (!localFile && !subcommand._executableFile && this._scriptPath) { |
| 2237 | const legacyName = path5.basename( |
| 2238 | this._scriptPath, |
| 2239 | path5.extname(this._scriptPath) |
| 2240 | ); |
| 2241 | if (legacyName !== this._name) { |
| 2242 | localFile = findFile( |
| 2243 | executableDir, |
| 2244 | `${legacyName}-${subcommand._name}` |
| 2245 | ); |
| 2246 | } |
| 2247 | } |
| 2248 | executableFile = localFile || executableFile; |
| 2249 | } |
| 2250 | launchWithNode = sourceExt.includes(path5.extname(executableFile)); |
| 2251 | let proc; |
| 2252 | if (process2.platform !== "win32") { |
| 2253 | if (launchWithNode) { |
| 2254 | args.unshift(executableFile); |
| 2255 | args = incrementNodeInspectorPort(process2.execArgv).concat(args); |
| 2256 | proc = childProcess.spawn(process2.argv[0], args, { stdio: "inherit" }); |
| 2257 | } else { |
| 2258 | proc = childProcess.spawn(executableFile, args, { stdio: "inherit" }); |
| 2259 | } |
| 2260 | } else { |
| 2261 | this._checkForMissingExecutable( |
| 2262 | executableFile, |
| 2263 | executableDir, |
| 2264 | subcommand._name |
| 2265 | ); |
| 2266 | args.unshift(executableFile); |
| 2267 | args = incrementNodeInspectorPort(process2.execArgv).concat(args); |
| 2268 | proc = childProcess.spawn(process2.execPath, args, { stdio: "inherit" }); |
| 2269 | } |
| 2270 | if (!proc.killed) { |
| 2271 | const signals = ["SIGUSR1", "SIGUSR2", "SIGTERM", "SIGINT", "SIGHUP"]; |
| 2272 | signals.forEach((signal) => { |
| 2273 | process2.on(signal, () => { |
| 2274 | if (proc.killed === false && proc.exitCode === null) { |
| 2275 | proc.kill(signal); |
| 2276 | } |
| 2277 | }); |
| 2278 | }); |
| 2279 | } |
| 2280 | const exitCallback = this._exitCallback; |
| 2281 | proc.on("close", (code) => { |
| 2282 | code = code ?? 1; |
| 2283 | if (!exitCallback) { |
| 2284 | process2.exit(code); |
| 2285 | } else { |
| 2286 | exitCallback( |
| 2287 | new CommanderError2( |
| 2288 | code, |
| 2289 | "commander.executeSubCommandAsync", |
| 2290 | "(close)" |
| 2291 | ) |
| 2292 | ); |
| 2293 | } |
| 2294 | }); |
| 2295 | proc.on("error", (err) => { |
| 2296 | if (err.code === "ENOENT") { |
| 2297 | this._checkForMissingExecutable( |
| 2298 | executableFile, |
| 2299 | executableDir, |
| 2300 | subcommand._name |
| 2301 | ); |
| 2302 | } else if (err.code === "EACCES") { |
| 2303 | throw new Error(`'${executableFile}' not executable`); |
| 2304 | } |
| 2305 | if (!exitCallback) { |
| 2306 | process2.exit(1); |
| 2307 | } else { |
| 2308 | const wrappedError = new CommanderError2( |
| 2309 | 1, |
| 2310 | "commander.executeSubCommandAsync", |
| 2311 | "(error)" |
| 2312 | ); |
| 2313 | wrappedError.nestedError = err; |
| 2314 | exitCallback(wrappedError); |
| 2315 | } |
| 2316 | }); |
| 2317 | this.runningCommand = proc; |
| 2318 | } |
| 2319 | /** |
| 2320 | * @private |
| 2321 | */ |
| 2322 | _dispatchSubcommand(commandName, operands, unknown) { |
| 2323 | const subCommand = this._findCommand(commandName); |
| 2324 | if (!subCommand) this.help({ error: true }); |
| 2325 | subCommand._prepareForParse(); |
| 2326 | let promiseChain; |
| 2327 | promiseChain = this._chainOrCallSubCommandHook( |
| 2328 | promiseChain, |
| 2329 | subCommand, |
| 2330 | "preSubcommand" |
| 2331 | ); |
| 2332 | promiseChain = this._chainOrCall(promiseChain, () => { |
| 2333 | if (subCommand._executableHandler) { |
| 2334 | this._executeSubCommand(subCommand, operands.concat(unknown)); |
| 2335 | } else { |
| 2336 | return subCommand._parseCommand(operands, unknown); |
| 2337 | } |
| 2338 | }); |
| 2339 | return promiseChain; |
| 2340 | } |
| 2341 | /** |
| 2342 | * Invoke help directly if possible, or dispatch if necessary. |
| 2343 | * e.g. help foo |
| 2344 | * |
| 2345 | * @private |
| 2346 | */ |
| 2347 | _dispatchHelpCommand(subcommandName) { |
| 2348 | if (!subcommandName) { |
| 2349 | this.help(); |
| 2350 | } |
| 2351 | const subCommand = this._findCommand(subcommandName); |
| 2352 | if (subCommand && !subCommand._executableHandler) { |
| 2353 | subCommand.help(); |
| 2354 | } |
| 2355 | return this._dispatchSubcommand( |
| 2356 | subcommandName, |
| 2357 | [], |
| 2358 | [this._getHelpOption()?.long ?? this._getHelpOption()?.short ?? "--help"] |
| 2359 | ); |
| 2360 | } |
| 2361 | /** |
| 2362 | * Check this.args against expected this.registeredArguments. |
| 2363 | * |
| 2364 | * @private |
| 2365 | */ |
| 2366 | _checkNumberOfArguments() { |
| 2367 | this.registeredArguments.forEach((arg, i) => { |
| 2368 | if (arg.required && this.args[i] == null) { |
| 2369 | this.missingArgument(arg.name()); |
| 2370 | } |
| 2371 | }); |
| 2372 | if (this.registeredArguments.length > 0 && this.registeredArguments[this.registeredArguments.length - 1].variadic) { |
| 2373 | return; |
| 2374 | } |
| 2375 | if (this.args.length > this.registeredArguments.length) { |
| 2376 | this._excessArguments(this.args); |
| 2377 | } |
| 2378 | } |
| 2379 | /** |
| 2380 | * Process this.args using this.registeredArguments and save as this.processedArgs! |
| 2381 | * |
| 2382 | * @private |
| 2383 | */ |
| 2384 | _processArguments() { |
| 2385 | const myParseArg = (argument, value, previous) => { |
| 2386 | let parsedValue = value; |
| 2387 | if (value !== null && argument.parseArg) { |
| 2388 | const invalidValueMessage = `error: command-argument value '${value}' is invalid for argument '${argument.name()}'.`; |
| 2389 | parsedValue = this._callParseArg( |
| 2390 | argument, |
| 2391 | value, |
| 2392 | previous, |
| 2393 | invalidValueMessage |
| 2394 | ); |
| 2395 | } |
| 2396 | return parsedValue; |
| 2397 | }; |
| 2398 | this._checkNumberOfArguments(); |
| 2399 | const processedArgs = []; |
| 2400 | this.registeredArguments.forEach((declaredArg, index) => { |
| 2401 | let value = declaredArg.defaultValue; |
| 2402 | if (declaredArg.variadic) { |
| 2403 | if (index < this.args.length) { |
| 2404 | value = this.args.slice(index); |
| 2405 | if (declaredArg.parseArg) { |
| 2406 | value = value.reduce((processed, v) => { |
| 2407 | return myParseArg(declaredArg, v, processed); |
| 2408 | }, declaredArg.defaultValue); |
| 2409 | } |
| 2410 | } else if (value === void 0) { |
| 2411 | value = []; |
| 2412 | } |
| 2413 | } else if (index < this.args.length) { |
| 2414 | value = this.args[index]; |
| 2415 | if (declaredArg.parseArg) { |
| 2416 | value = myParseArg(declaredArg, value, declaredArg.defaultValue); |
| 2417 | } |
| 2418 | } |
| 2419 | processedArgs[index] = value; |
| 2420 | }); |
| 2421 | this.processedArgs = processedArgs; |
| 2422 | } |
| 2423 | /** |
| 2424 | * Once we have a promise we chain, but call synchronously until then. |
| 2425 | * |
| 2426 | * @param {(Promise|undefined)} promise |
| 2427 | * @param {Function} fn |
| 2428 | * @return {(Promise|undefined)} |
| 2429 | * @private |
| 2430 | */ |
| 2431 | _chainOrCall(promise, fn) { |
| 2432 | if (promise?.then && typeof promise.then === "function") { |
| 2433 | return promise.then(() => fn()); |
| 2434 | } |
| 2435 | return fn(); |
| 2436 | } |
| 2437 | /** |
| 2438 | * |
| 2439 | * @param {(Promise|undefined)} promise |
| 2440 | * @param {string} event |
| 2441 | * @return {(Promise|undefined)} |
| 2442 | * @private |
| 2443 | */ |
| 2444 | _chainOrCallHooks(promise, event) { |
| 2445 | let result = promise; |
| 2446 | const hooks = []; |
| 2447 | this._getCommandAndAncestors().reverse().filter((cmd) => cmd._lifeCycleHooks[event] !== void 0).forEach((hookedCommand) => { |
| 2448 | hookedCommand._lifeCycleHooks[event].forEach((callback) => { |
| 2449 | hooks.push({ hookedCommand, callback }); |
| 2450 | }); |
| 2451 | }); |
| 2452 | if (event === "postAction") { |
| 2453 | hooks.reverse(); |
| 2454 | } |
| 2455 | hooks.forEach((hookDetail) => { |
| 2456 | result = this._chainOrCall(result, () => { |
| 2457 | return hookDetail.callback(hookDetail.hookedCommand, this); |
| 2458 | }); |
| 2459 | }); |
| 2460 | return result; |
| 2461 | } |
| 2462 | /** |
| 2463 | * |
| 2464 | * @param {(Promise|undefined)} promise |
| 2465 | * @param {Command} subCommand |
| 2466 | * @param {string} event |
| 2467 | * @return {(Promise|undefined)} |
| 2468 | * @private |
| 2469 | */ |
| 2470 | _chainOrCallSubCommandHook(promise, subCommand, event) { |
| 2471 | let result = promise; |
| 2472 | if (this._lifeCycleHooks[event] !== void 0) { |
| 2473 | this._lifeCycleHooks[event].forEach((hook2) => { |
| 2474 | result = this._chainOrCall(result, () => { |
| 2475 | return hook2(this, subCommand); |
| 2476 | }); |
| 2477 | }); |
| 2478 | } |
| 2479 | return result; |
| 2480 | } |
| 2481 | /** |
| 2482 | * Process arguments in context of this command. |
| 2483 | * Returns action result, in case it is a promise. |
| 2484 | * |
| 2485 | * @private |
| 2486 | */ |
| 2487 | _parseCommand(operands, unknown) { |
| 2488 | const parsed = this.parseOptions(unknown); |
| 2489 | this._parseOptionsEnv(); |
| 2490 | this._parseOptionsImplied(); |
| 2491 | operands = operands.concat(parsed.operands); |
| 2492 | unknown = parsed.unknown; |
| 2493 | this.args = operands.concat(unknown); |
| 2494 | if (operands && this._findCommand(operands[0])) { |
| 2495 | return this._dispatchSubcommand(operands[0], operands.slice(1), unknown); |
| 2496 | } |
| 2497 | if (this._getHelpCommand() && operands[0] === this._getHelpCommand().name()) { |
| 2498 | return this._dispatchHelpCommand(operands[1]); |
| 2499 | } |
| 2500 | if (this._defaultCommandName) { |
| 2501 | this._outputHelpIfRequested(unknown); |
| 2502 | return this._dispatchSubcommand( |
| 2503 | this._defaultCommandName, |
| 2504 | operands, |
| 2505 | unknown |
| 2506 | ); |
| 2507 | } |
| 2508 | if (this.commands.length && this.args.length === 0 && !this._actionHandler && !this._defaultCommandName) { |
| 2509 | this.help({ error: true }); |
| 2510 | } |
| 2511 | this._outputHelpIfRequested(parsed.unknown); |
| 2512 | this._checkForMissingMandatoryOptions(); |
| 2513 | this._checkForConflictingOptions(); |
| 2514 | const checkForUnknownOptions = () => { |
| 2515 | if (parsed.unknown.length > 0) { |
| 2516 | this.unknownOption(parsed.unknown[0]); |
| 2517 | } |
| 2518 | }; |
| 2519 | const commandEvent = `command:${this.name()}`; |
| 2520 | if (this._actionHandler) { |
| 2521 | checkForUnknownOptions(); |
| 2522 | this._processArguments(); |
| 2523 | let promiseChain; |
| 2524 | promiseChain = this._chainOrCallHooks(promiseChain, "preAction"); |
| 2525 | promiseChain = this._chainOrCall( |
| 2526 | promiseChain, |
| 2527 | () => this._actionHandler(this.processedArgs) |
| 2528 | ); |
| 2529 | if (this.parent) { |
| 2530 | promiseChain = this._chainOrCall(promiseChain, () => { |
| 2531 | this.parent.emit(commandEvent, operands, unknown); |
| 2532 | }); |
| 2533 | } |
| 2534 | promiseChain = this._chainOrCallHooks(promiseChain, "postAction"); |
| 2535 | return promiseChain; |
| 2536 | } |
| 2537 | if (this.parent?.listenerCount(commandEvent)) { |
| 2538 | checkForUnknownOptions(); |
| 2539 | this._processArguments(); |
| 2540 | this.parent.emit(commandEvent, operands, unknown); |
| 2541 | } else if (operands.length) { |
| 2542 | if (this._findCommand("*")) { |
| 2543 | return this._dispatchSubcommand("*", operands, unknown); |
| 2544 | } |
| 2545 | if (this.listenerCount("command:*")) { |
| 2546 | this.emit("command:*", operands, unknown); |
| 2547 | } else if (this.commands.length) { |
| 2548 | this.unknownCommand(); |
| 2549 | } else { |
| 2550 | checkForUnknownOptions(); |
| 2551 | this._processArguments(); |
| 2552 | } |
| 2553 | } else if (this.commands.length) { |
| 2554 | checkForUnknownOptions(); |
| 2555 | this.help({ error: true }); |
| 2556 | } else { |
| 2557 | checkForUnknownOptions(); |
| 2558 | this._processArguments(); |
| 2559 | } |
| 2560 | } |
| 2561 | /** |
| 2562 | * Find matching command. |
| 2563 | * |
| 2564 | * @private |
| 2565 | * @return {Command | undefined} |
| 2566 | */ |
| 2567 | _findCommand(name) { |
| 2568 | if (!name) return void 0; |
| 2569 | return this.commands.find( |
| 2570 | (cmd) => cmd._name === name || cmd._aliases.includes(name) |
| 2571 | ); |
| 2572 | } |
| 2573 | /** |
| 2574 | * Return an option matching `arg` if any. |
| 2575 | * |
| 2576 | * @param {string} arg |
| 2577 | * @return {Option} |
| 2578 | * @package |
| 2579 | */ |
| 2580 | _findOption(arg) { |
| 2581 | return this.options.find((option) => option.is(arg)); |
| 2582 | } |
| 2583 | /** |
| 2584 | * Display an error message if a mandatory option does not have a value. |
| 2585 | * Called after checking for help flags in leaf subcommand. |
| 2586 | * |
| 2587 | * @private |
| 2588 | */ |
| 2589 | _checkForMissingMandatoryOptions() { |
| 2590 | this._getCommandAndAncestors().forEach((cmd) => { |
| 2591 | cmd.options.forEach((anOption) => { |
| 2592 | if (anOption.mandatory && cmd.getOptionValue(anOption.attributeName()) === void 0) { |
| 2593 | cmd.missingMandatoryOptionValue(anOption); |
| 2594 | } |
| 2595 | }); |
| 2596 | }); |
| 2597 | } |
| 2598 | /** |
| 2599 | * Display an error message if conflicting options are used together in this. |
| 2600 | * |
| 2601 | * @private |
| 2602 | */ |
| 2603 | _checkForConflictingLocalOptions() { |
| 2604 | const definedNonDefaultOptions = this.options.filter((option) => { |
| 2605 | const optionKey = option.attributeName(); |
| 2606 | if (this.getOptionValue(optionKey) === void 0) { |
| 2607 | return false; |
| 2608 | } |
| 2609 | return this.getOptionValueSource(optionKey) !== "default"; |
| 2610 | }); |
| 2611 | const optionsWithConflicting = definedNonDefaultOptions.filter( |
| 2612 | (option) => option.conflictsWith.length > 0 |
| 2613 | ); |
| 2614 | optionsWithConflicting.forEach((option) => { |
| 2615 | const conflictingAndDefined = definedNonDefaultOptions.find( |
| 2616 | (defined) => option.conflictsWith.includes(defined.attributeName()) |
| 2617 | ); |
| 2618 | if (conflictingAndDefined) { |
| 2619 | this._conflictingOption(option, conflictingAndDefined); |
| 2620 | } |
| 2621 | }); |
| 2622 | } |
| 2623 | /** |
| 2624 | * Display an error message if conflicting options are used together. |
| 2625 | * Called after checking for help flags in leaf subcommand. |
| 2626 | * |
| 2627 | * @private |
| 2628 | */ |
| 2629 | _checkForConflictingOptions() { |
| 2630 | this._getCommandAndAncestors().forEach((cmd) => { |
| 2631 | cmd._checkForConflictingLocalOptions(); |
| 2632 | }); |
| 2633 | } |
| 2634 | /** |
| 2635 | * Parse options from `argv` removing known options, |
| 2636 | * and return argv split into operands and unknown arguments. |
| 2637 | * |
| 2638 | * Side effects: modifies command by storing options. Does not reset state if called again. |
| 2639 | * |
| 2640 | * Examples: |
| 2641 | * |
| 2642 | * argv => operands, unknown |
| 2643 | * --known kkk op => [op], [] |
| 2644 | * op --known kkk => [op], [] |
| 2645 | * sub --unknown uuu op => [sub], [--unknown uuu op] |
| 2646 | * sub -- --unknown uuu op => [sub --unknown uuu op], [] |
| 2647 | * |
| 2648 | * @param {string[]} args |
| 2649 | * @return {{operands: string[], unknown: string[]}} |
| 2650 | */ |
| 2651 | parseOptions(args) { |
| 2652 | const operands = []; |
| 2653 | const unknown = []; |
| 2654 | let dest = operands; |
| 2655 | function maybeOption(arg) { |
| 2656 | return arg.length > 1 && arg[0] === "-"; |
| 2657 | } |
| 2658 | const negativeNumberArg = (arg) => { |
| 2659 | if (!/^-\d*\.?\d+(e[+-]?\d+)?$/.test(arg)) return false; |
| 2660 | return !this._getCommandAndAncestors().some( |
| 2661 | (cmd) => cmd.options.map((opt) => opt.short).some((short) => /^-\d$/.test(short)) |
| 2662 | ); |
| 2663 | }; |
| 2664 | let activeVariadicOption = null; |
| 2665 | let activeGroup = null; |
| 2666 | let i = 0; |
| 2667 | while (i < args.length || activeGroup) { |
| 2668 | const arg = activeGroup ?? args[i++]; |
| 2669 | activeGroup = null; |
| 2670 | if (arg === "--") { |
| 2671 | if (dest === unknown) dest.push(arg); |
| 2672 | dest.push(...args.slice(i)); |
| 2673 | break; |
| 2674 | } |
| 2675 | if (activeVariadicOption && (!maybeOption(arg) || negativeNumberArg(arg))) { |
| 2676 | this.emit(`option:${activeVariadicOption.name()}`, arg); |
| 2677 | continue; |
| 2678 | } |
| 2679 | activeVariadicOption = null; |
| 2680 | if (maybeOption(arg)) { |
| 2681 | const option = this._findOption(arg); |
| 2682 | if (option) { |
| 2683 | if (option.required) { |
| 2684 | const value = args[i++]; |
| 2685 | if (value === void 0) this.optionMissingArgument(option); |
| 2686 | this.emit(`option:${option.name()}`, value); |
| 2687 | } else if (option.optional) { |
| 2688 | let value = null; |
| 2689 | if (i < args.length && (!maybeOption(args[i]) || negativeNumberArg(args[i]))) { |
| 2690 | value = args[i++]; |
| 2691 | } |
| 2692 | this.emit(`option:${option.name()}`, value); |
| 2693 | } else { |
| 2694 | this.emit(`option:${option.name()}`); |
| 2695 | } |
| 2696 | activeVariadicOption = option.variadic ? option : null; |
| 2697 | continue; |
| 2698 | } |
| 2699 | } |
| 2700 | if (arg.length > 2 && arg[0] === "-" && arg[1] !== "-") { |
| 2701 | const option = this._findOption(`-${arg[1]}`); |
| 2702 | if (option) { |
| 2703 | if (option.required || option.optional && this._combineFlagAndOptionalValue) { |
| 2704 | this.emit(`option:${option.name()}`, arg.slice(2)); |
| 2705 | } else { |
| 2706 | this.emit(`option:${option.name()}`); |
| 2707 | activeGroup = `-${arg.slice(2)}`; |
| 2708 | } |
| 2709 | continue; |
| 2710 | } |
| 2711 | } |
| 2712 | if (/^--[^=]+=/.test(arg)) { |
| 2713 | const index = arg.indexOf("="); |
| 2714 | const option = this._findOption(arg.slice(0, index)); |
| 2715 | if (option && (option.required || option.optional)) { |
| 2716 | this.emit(`option:${option.name()}`, arg.slice(index + 1)); |
| 2717 | continue; |
| 2718 | } |
| 2719 | } |
| 2720 | if (dest === operands && maybeOption(arg) && !(this.commands.length === 0 && negativeNumberArg(arg))) { |
| 2721 | dest = unknown; |
| 2722 | } |
| 2723 | if ((this._enablePositionalOptions || this._passThroughOptions) && operands.length === 0 && unknown.length === 0) { |
| 2724 | if (this._findCommand(arg)) { |
| 2725 | operands.push(arg); |
| 2726 | unknown.push(...args.slice(i)); |
| 2727 | break; |
| 2728 | } else if (this._getHelpCommand() && arg === this._getHelpCommand().name()) { |
| 2729 | operands.push(arg, ...args.slice(i)); |
| 2730 | break; |
| 2731 | } else if (this._defaultCommandName) { |
| 2732 | unknown.push(arg, ...args.slice(i)); |
| 2733 | break; |
| 2734 | } |
| 2735 | } |
| 2736 | if (this._passThroughOptions) { |
| 2737 | dest.push(arg, ...args.slice(i)); |
| 2738 | break; |
| 2739 | } |
| 2740 | dest.push(arg); |
| 2741 | } |
| 2742 | return { operands, unknown }; |
| 2743 | } |
| 2744 | /** |
| 2745 | * Return an object containing local option values as key-value pairs. |
| 2746 | * |
| 2747 | * @return {object} |
| 2748 | */ |
| 2749 | opts() { |
| 2750 | if (this._storeOptionsAsProperties) { |
| 2751 | const result = {}; |
| 2752 | const len = this.options.length; |
| 2753 | for (let i = 0; i < len; i++) { |
| 2754 | const key = this.options[i].attributeName(); |
| 2755 | result[key] = key === this._versionOptionName ? this._version : this[key]; |
| 2756 | } |
| 2757 | return result; |
| 2758 | } |
| 2759 | return this._optionValues; |
| 2760 | } |
| 2761 | /** |
| 2762 | * Return an object containing merged local and global option values as key-value pairs. |
| 2763 | * |
| 2764 | * @return {object} |
| 2765 | */ |
| 2766 | optsWithGlobals() { |
| 2767 | return this._getCommandAndAncestors().reduce( |
| 2768 | (combinedOptions, cmd) => Object.assign(combinedOptions, cmd.opts()), |
| 2769 | {} |
| 2770 | ); |
| 2771 | } |
| 2772 | /** |
| 2773 | * Display error message and exit (or call exitOverride). |
| 2774 | * |
| 2775 | * @param {string} message |
| 2776 | * @param {object} [errorOptions] |
| 2777 | * @param {string} [errorOptions.code] - an id string representing the error |
| 2778 | * @param {number} [errorOptions.exitCode] - used with process.exit |
| 2779 | */ |
| 2780 | error(message, errorOptions) { |
| 2781 | this._outputConfiguration.outputError( |
| 2782 | `${message} |
| 2783 | `, |
| 2784 | this._outputConfiguration.writeErr |
| 2785 | ); |
| 2786 | if (typeof this._showHelpAfterError === "string") { |
| 2787 | this._outputConfiguration.writeErr(`${this._showHelpAfterError} |
| 2788 | `); |
| 2789 | } else if (this._showHelpAfterError) { |
| 2790 | this._outputConfiguration.writeErr("\n"); |
| 2791 | this.outputHelp({ error: true }); |
| 2792 | } |
| 2793 | const config = errorOptions || {}; |
| 2794 | const exitCode = config.exitCode || 1; |
| 2795 | const code = config.code || "commander.error"; |
| 2796 | this._exit(exitCode, code, message); |
| 2797 | } |
| 2798 | /** |
| 2799 | * Apply any option related environment variables, if option does |
| 2800 | * not have a value from cli or client code. |
| 2801 | * |
| 2802 | * @private |
| 2803 | */ |
| 2804 | _parseOptionsEnv() { |
| 2805 | this.options.forEach((option) => { |
| 2806 | if (option.envVar && option.envVar in process2.env) { |
| 2807 | const optionKey = option.attributeName(); |
| 2808 | if (this.getOptionValue(optionKey) === void 0 || ["default", "config", "env"].includes( |
| 2809 | this.getOptionValueSource(optionKey) |
| 2810 | )) { |
| 2811 | if (option.required || option.optional) { |
| 2812 | this.emit(`optionEnv:${option.name()}`, process2.env[option.envVar]); |
| 2813 | } else { |
| 2814 | this.emit(`optionEnv:${option.name()}`); |
| 2815 | } |
| 2816 | } |
| 2817 | } |
| 2818 | }); |
| 2819 | } |
| 2820 | /** |
| 2821 | * Apply any implied option values, if option is undefined or default value. |
| 2822 | * |
| 2823 | * @private |
| 2824 | */ |
| 2825 | _parseOptionsImplied() { |
| 2826 | const dualHelper = new DualOptions(this.options); |
| 2827 | const hasCustomOptionValue = (optionKey) => { |
| 2828 | return this.getOptionValue(optionKey) !== void 0 && !["default", "implied"].includes(this.getOptionValueSource(optionKey)); |
| 2829 | }; |
| 2830 | this.options.filter( |
| 2831 | (option) => option.implied !== void 0 && hasCustomOptionValue(option.attributeName()) && dualHelper.valueFromOption( |
| 2832 | this.getOptionValue(option.attributeName()), |
| 2833 | option |
| 2834 | ) |
| 2835 | ).forEach((option) => { |
| 2836 | Object.keys(option.implied).filter((impliedKey) => !hasCustomOptionValue(impliedKey)).forEach((impliedKey) => { |
| 2837 | this.setOptionValueWithSource( |
| 2838 | impliedKey, |
| 2839 | option.implied[impliedKey], |
| 2840 | "implied" |
| 2841 | ); |
| 2842 | }); |
| 2843 | }); |
| 2844 | } |
| 2845 | /** |
| 2846 | * Argument `name` is missing. |
| 2847 | * |
| 2848 | * @param {string} name |
| 2849 | * @private |
| 2850 | */ |
| 2851 | missingArgument(name) { |
| 2852 | const message = `error: missing required argument '${name}'`; |
| 2853 | this.error(message, { code: "commander.missingArgument" }); |
| 2854 | } |
| 2855 | /** |
| 2856 | * `Option` is missing an argument. |
| 2857 | * |
| 2858 | * @param {Option} option |
| 2859 | * @private |
| 2860 | */ |
| 2861 | optionMissingArgument(option) { |
| 2862 | const message = `error: option '${option.flags}' argument missing`; |
| 2863 | this.error(message, { code: "commander.optionMissingArgument" }); |
| 2864 | } |
| 2865 | /** |
| 2866 | * `Option` does not have a value, and is a mandatory option. |
| 2867 | * |
| 2868 | * @param {Option} option |
| 2869 | * @private |
| 2870 | */ |
| 2871 | missingMandatoryOptionValue(option) { |
| 2872 | const message = `error: required option '${option.flags}' not specified`; |
| 2873 | this.error(message, { code: "commander.missingMandatoryOptionValue" }); |
| 2874 | } |
| 2875 | /** |
| 2876 | * `Option` conflicts with another option. |
| 2877 | * |
| 2878 | * @param {Option} option |
| 2879 | * @param {Option} conflictingOption |
| 2880 | * @private |
| 2881 | */ |
| 2882 | _conflictingOption(option, conflictingOption) { |
| 2883 | const findBestOptionFromValue = (option2) => { |
| 2884 | const optionKey = option2.attributeName(); |
| 2885 | const optionValue = this.getOptionValue(optionKey); |
| 2886 | const negativeOption = this.options.find( |
| 2887 | (target) => target.negate && optionKey === target.attributeName() |
| 2888 | ); |
| 2889 | const positiveOption = this.options.find( |
| 2890 | (target) => !target.negate && optionKey === target.attributeName() |
| 2891 | ); |
| 2892 | if (negativeOption && (negativeOption.presetArg === void 0 && optionValue === false || negativeOption.presetArg !== void 0 && optionValue === negativeOption.presetArg)) { |
| 2893 | return negativeOption; |
| 2894 | } |
| 2895 | return positiveOption || option2; |
| 2896 | }; |
| 2897 | const getErrorMessage = (option2) => { |
| 2898 | const bestOption = findBestOptionFromValue(option2); |
| 2899 | const optionKey = bestOption.attributeName(); |
| 2900 | const source = this.getOptionValueSource(optionKey); |
| 2901 | if (source === "env") { |
| 2902 | return `environment variable '${bestOption.envVar}'`; |
| 2903 | } |
| 2904 | return `option '${bestOption.flags}'`; |
| 2905 | }; |
| 2906 | const message = `error: ${getErrorMessage(option)} cannot be used with ${getErrorMessage(conflictingOption)}`; |
| 2907 | this.error(message, { code: "commander.conflictingOption" }); |
| 2908 | } |
| 2909 | /** |
| 2910 | * Unknown option `flag`. |
| 2911 | * |
| 2912 | * @param {string} flag |
| 2913 | * @private |
| 2914 | */ |
| 2915 | unknownOption(flag) { |
| 2916 | if (this._allowUnknownOption) return; |
| 2917 | let suggestion = ""; |
| 2918 | if (flag.startsWith("--") && this._showSuggestionAfterError) { |
| 2919 | let candidateFlags = []; |
| 2920 | let command = this; |
| 2921 | do { |
| 2922 | const moreFlags = command.createHelp().visibleOptions(command).filter((option) => option.long).map((option) => option.long); |
| 2923 | candidateFlags = candidateFlags.concat(moreFlags); |
| 2924 | command = command.parent; |
| 2925 | } while (command && !command._enablePositionalOptions); |
| 2926 | suggestion = suggestSimilar(flag, candidateFlags); |
| 2927 | } |
| 2928 | const message = `error: unknown option '${flag}'${suggestion}`; |
| 2929 | this.error(message, { code: "commander.unknownOption" }); |
| 2930 | } |
| 2931 | /** |
| 2932 | * Excess arguments, more than expected. |
| 2933 | * |
| 2934 | * @param {string[]} receivedArgs |
| 2935 | * @private |
| 2936 | */ |
| 2937 | _excessArguments(receivedArgs) { |
| 2938 | if (this._allowExcessArguments) return; |
| 2939 | const expected = this.registeredArguments.length; |
| 2940 | const s = expected === 1 ? "" : "s"; |
| 2941 | const forSubcommand = this.parent ? ` for '${this.name()}'` : ""; |
| 2942 | const message = `error: too many arguments${forSubcommand}. Expected ${expected} argument${s} but got ${receivedArgs.length}.`; |
| 2943 | this.error(message, { code: "commander.excessArguments" }); |
| 2944 | } |
| 2945 | /** |
| 2946 | * Unknown command. |
| 2947 | * |
| 2948 | * @private |
| 2949 | */ |
| 2950 | unknownCommand() { |
| 2951 | const unknownName = this.args[0]; |
| 2952 | let suggestion = ""; |
| 2953 | if (this._showSuggestionAfterError) { |
| 2954 | const candidateNames = []; |
| 2955 | this.createHelp().visibleCommands(this).forEach((command) => { |
| 2956 | candidateNames.push(command.name()); |
| 2957 | if (command.alias()) candidateNames.push(command.alias()); |
| 2958 | }); |
| 2959 | suggestion = suggestSimilar(unknownName, candidateNames); |
| 2960 | } |
| 2961 | const message = `error: unknown command '${unknownName}'${suggestion}`; |
| 2962 | this.error(message, { code: "commander.unknownCommand" }); |
| 2963 | } |
| 2964 | /** |
| 2965 | * Get or set the program version. |
| 2966 | * |
| 2967 | * This method auto-registers the "-V, --version" option which will print the version number. |
| 2968 | * |
| 2969 | * You can optionally supply the flags and description to override the defaults. |
| 2970 | * |
| 2971 | * @param {string} [str] |
| 2972 | * @param {string} [flags] |
| 2973 | * @param {string} [description] |
| 2974 | * @return {(this | string | undefined)} `this` command for chaining, or version string if no arguments |
| 2975 | */ |
| 2976 | version(str, flags, description) { |
| 2977 | if (str === void 0) return this._version; |
| 2978 | this._version = str; |
| 2979 | flags = flags || "-V, --version"; |
| 2980 | description = description || "output the version number"; |
| 2981 | const versionOption = this.createOption(flags, description); |
| 2982 | this._versionOptionName = versionOption.attributeName(); |
| 2983 | this._registerOption(versionOption); |
| 2984 | this.on("option:" + versionOption.name(), () => { |
| 2985 | this._outputConfiguration.writeOut(`${str} |
| 2986 | `); |
| 2987 | this._exit(0, "commander.version", str); |
| 2988 | }); |
| 2989 | return this; |
| 2990 | } |
| 2991 | /** |
| 2992 | * Set the description. |
| 2993 | * |
| 2994 | * @param {string} [str] |
| 2995 | * @param {object} [argsDescription] |
| 2996 | * @return {(string|Command)} |
| 2997 | */ |
| 2998 | description(str, argsDescription) { |
| 2999 | if (str === void 0 && argsDescription === void 0) |
| 3000 | return this._description; |
| 3001 | this._description = str; |
| 3002 | if (argsDescription) { |
| 3003 | this._argsDescription = argsDescription; |
| 3004 | } |
| 3005 | return this; |
| 3006 | } |
| 3007 | /** |
| 3008 | * Set the summary. Used when listed as subcommand of parent. |
| 3009 | * |
| 3010 | * @param {string} [str] |
| 3011 | * @return {(string|Command)} |
| 3012 | */ |
| 3013 | summary(str) { |
| 3014 | if (str === void 0) return this._summary; |
| 3015 | this._summary = str; |
| 3016 | return this; |
| 3017 | } |
| 3018 | /** |
| 3019 | * Set an alias for the command. |
| 3020 | * |
| 3021 | * You may call more than once to add multiple aliases. Only the first alias is shown in the auto-generated help. |
| 3022 | * |
| 3023 | * @param {string} [alias] |
| 3024 | * @return {(string|Command)} |
| 3025 | */ |
| 3026 | alias(alias) { |
| 3027 | if (alias === void 0) return this._aliases[0]; |
| 3028 | let command = this; |
| 3029 | if (this.commands.length !== 0 && this.commands[this.commands.length - 1]._executableHandler) { |
| 3030 | command = this.commands[this.commands.length - 1]; |
| 3031 | } |
| 3032 | if (alias === command._name) |
| 3033 | throw new Error("Command alias can't be the same as its name"); |
| 3034 | const matchingCommand = this.parent?._findCommand(alias); |
| 3035 | if (matchingCommand) { |
| 3036 | const existingCmd = [matchingCommand.name()].concat(matchingCommand.aliases()).join("|"); |
| 3037 | throw new Error( |
| 3038 | `cannot add alias '${alias}' to command '${this.name()}' as already have command '${existingCmd}'` |
| 3039 | ); |
| 3040 | } |
| 3041 | command._aliases.push(alias); |
| 3042 | return this; |
| 3043 | } |
| 3044 | /** |
| 3045 | * Set aliases for the command. |
| 3046 | * |
| 3047 | * Only the first alias is shown in the auto-generated help. |
| 3048 | * |
| 3049 | * @param {string[]} [aliases] |
| 3050 | * @return {(string[]|Command)} |
| 3051 | */ |
| 3052 | aliases(aliases) { |
| 3053 | if (aliases === void 0) return this._aliases; |
| 3054 | aliases.forEach((alias) => this.alias(alias)); |
| 3055 | return this; |
| 3056 | } |
| 3057 | /** |
| 3058 | * Set / get the command usage `str`. |
| 3059 | * |
| 3060 | * @param {string} [str] |
| 3061 | * @return {(string|Command)} |
| 3062 | */ |
| 3063 | usage(str) { |
| 3064 | if (str === void 0) { |
| 3065 | if (this._usage) return this._usage; |
| 3066 | const args = this.registeredArguments.map((arg) => { |
| 3067 | return humanReadableArgName(arg); |
| 3068 | }); |
| 3069 | return [].concat( |
| 3070 | this.options.length || this._helpOption !== null ? "[options]" : [], |
| 3071 | this.commands.length ? "[command]" : [], |
| 3072 | this.registeredArguments.length ? args : [] |
| 3073 | ).join(" "); |
| 3074 | } |
| 3075 | this._usage = str; |
| 3076 | return this; |
| 3077 | } |
| 3078 | /** |
| 3079 | * Get or set the name of the command. |
| 3080 | * |
| 3081 | * @param {string} [str] |
| 3082 | * @return {(string|Command)} |
| 3083 | */ |
| 3084 | name(str) { |
| 3085 | if (str === void 0) return this._name; |
| 3086 | this._name = str; |
| 3087 | return this; |
| 3088 | } |
| 3089 | /** |
| 3090 | * Set/get the help group heading for this subcommand in parent command's help. |
| 3091 | * |
| 3092 | * @param {string} [heading] |
| 3093 | * @return {Command | string} |
| 3094 | */ |
| 3095 | helpGroup(heading) { |
| 3096 | if (heading === void 0) return this._helpGroupHeading ?? ""; |
| 3097 | this._helpGroupHeading = heading; |
| 3098 | return this; |
| 3099 | } |
| 3100 | /** |
| 3101 | * Set/get the default help group heading for subcommands added to this command. |
| 3102 | * (This does not override a group set directly on the subcommand using .helpGroup().) |
| 3103 | * |
| 3104 | * @example |
| 3105 | * program.commandsGroup('Development Commands:); |
| 3106 | * program.command('watch')... |
| 3107 | * program.command('lint')... |
| 3108 | * ... |
| 3109 | * |
| 3110 | * @param {string} [heading] |
| 3111 | * @returns {Command | string} |
| 3112 | */ |
| 3113 | commandsGroup(heading) { |
| 3114 | if (heading === void 0) return this._defaultCommandGroup ?? ""; |
| 3115 | this._defaultCommandGroup = heading; |
| 3116 | return this; |
| 3117 | } |
| 3118 | /** |
| 3119 | * Set/get the default help group heading for options added to this command. |
| 3120 | * (This does not override a group set directly on the option using .helpGroup().) |
| 3121 | * |
| 3122 | * @example |
| 3123 | * program |
| 3124 | * .optionsGroup('Development Options:') |
| 3125 | * .option('-d, --debug', 'output extra debugging') |
| 3126 | * .option('-p, --profile', 'output profiling information') |
| 3127 | * |
| 3128 | * @param {string} [heading] |
| 3129 | * @returns {Command | string} |
| 3130 | */ |
| 3131 | optionsGroup(heading) { |
| 3132 | if (heading === void 0) return this._defaultOptionGroup ?? ""; |
| 3133 | this._defaultOptionGroup = heading; |
| 3134 | return this; |
| 3135 | } |
| 3136 | /** |
| 3137 | * @param {Option} option |
| 3138 | * @private |
| 3139 | */ |
| 3140 | _initOptionGroup(option) { |
| 3141 | if (this._defaultOptionGroup && !option.helpGroupHeading) |
| 3142 | option.helpGroup(this._defaultOptionGroup); |
| 3143 | } |
| 3144 | /** |
| 3145 | * @param {Command} cmd |
| 3146 | * @private |
| 3147 | */ |
| 3148 | _initCommandGroup(cmd) { |
| 3149 | if (this._defaultCommandGroup && !cmd.helpGroup()) |
| 3150 | cmd.helpGroup(this._defaultCommandGroup); |
| 3151 | } |
| 3152 | /** |
| 3153 | * Set the name of the command from script filename, such as process.argv[1], |
| 3154 | * or require.main.filename, or __filename. |
| 3155 | * |
| 3156 | * (Used internally and public although not documented in README.) |
| 3157 | * |
| 3158 | * @example |
| 3159 | * program.nameFromFilename(require.main.filename); |
| 3160 | * |
| 3161 | * @param {string} filename |
| 3162 | * @return {Command} |
| 3163 | */ |
| 3164 | nameFromFilename(filename) { |
| 3165 | this._name = path5.basename(filename, path5.extname(filename)); |
| 3166 | return this; |
| 3167 | } |
| 3168 | /** |
| 3169 | * Get or set the directory for searching for executable subcommands of this command. |
| 3170 | * |
| 3171 | * @example |
| 3172 | * program.executableDir(__dirname); |
| 3173 | * // or |
| 3174 | * program.executableDir('subcommands'); |
| 3175 | * |
| 3176 | * @param {string} [path] |
| 3177 | * @return {(string|null|Command)} |
| 3178 | */ |
| 3179 | executableDir(path6) { |
| 3180 | if (path6 === void 0) return this._executableDir; |
| 3181 | this._executableDir = path6; |
| 3182 | return this; |
| 3183 | } |
| 3184 | /** |
| 3185 | * Return program help documentation. |
| 3186 | * |
| 3187 | * @param {{ error: boolean }} [contextOptions] - pass {error:true} to wrap for stderr instead of stdout |
| 3188 | * @return {string} |
| 3189 | */ |
| 3190 | helpInformation(contextOptions) { |
| 3191 | const helper = this.createHelp(); |
| 3192 | const context = this._getOutputContext(contextOptions); |
| 3193 | helper.prepareContext({ |
| 3194 | error: context.error, |
| 3195 | helpWidth: context.helpWidth, |
| 3196 | outputHasColors: context.hasColors |
| 3197 | }); |
| 3198 | const text = helper.formatHelp(this, helper); |
| 3199 | if (context.hasColors) return text; |
| 3200 | return this._outputConfiguration.stripColor(text); |
| 3201 | } |
| 3202 | /** |
| 3203 | * @typedef HelpContext |
| 3204 | * @type {object} |
| 3205 | * @property {boolean} error |
| 3206 | * @property {number} helpWidth |
| 3207 | * @property {boolean} hasColors |
| 3208 | * @property {function} write - includes stripColor if needed |
| 3209 | * |
| 3210 | * @returns {HelpContext} |
| 3211 | * @private |
| 3212 | */ |
| 3213 | _getOutputContext(contextOptions) { |
| 3214 | contextOptions = contextOptions || {}; |
| 3215 | const error = !!contextOptions.error; |
| 3216 | let baseWrite; |
| 3217 | let hasColors; |
| 3218 | let helpWidth; |
| 3219 | if (error) { |
| 3220 | baseWrite = (str) => this._outputConfiguration.writeErr(str); |
| 3221 | hasColors = this._outputConfiguration.getErrHasColors(); |
| 3222 | helpWidth = this._outputConfiguration.getErrHelpWidth(); |
| 3223 | } else { |
| 3224 | baseWrite = (str) => this._outputConfiguration.writeOut(str); |
| 3225 | hasColors = this._outputConfiguration.getOutHasColors(); |
| 3226 | helpWidth = this._outputConfiguration.getOutHelpWidth(); |
| 3227 | } |
| 3228 | const write = (str) => { |
| 3229 | if (!hasColors) str = this._outputConfiguration.stripColor(str); |
| 3230 | return baseWrite(str); |
| 3231 | }; |
| 3232 | return { error, write, hasColors, helpWidth }; |
| 3233 | } |
| 3234 | /** |
| 3235 | * Output help information for this command. |
| 3236 | * |
| 3237 | * Outputs built-in help, and custom text added using `.addHelpText()`. |
| 3238 | * |
| 3239 | * @param {{ error: boolean } | Function} [contextOptions] - pass {error:true} to write to stderr instead of stdout |
| 3240 | */ |
| 3241 | outputHelp(contextOptions) { |
| 3242 | let deprecatedCallback; |
| 3243 | if (typeof contextOptions === "function") { |
| 3244 | deprecatedCallback = contextOptions; |
| 3245 | contextOptions = void 0; |
| 3246 | } |
| 3247 | const outputContext = this._getOutputContext(contextOptions); |
| 3248 | const eventContext = { |
| 3249 | error: outputContext.error, |
| 3250 | write: outputContext.write, |
| 3251 | command: this |
| 3252 | }; |
| 3253 | this._getCommandAndAncestors().reverse().forEach((command) => command.emit("beforeAllHelp", eventContext)); |
| 3254 | this.emit("beforeHelp", eventContext); |
| 3255 | let helpInformation = this.helpInformation({ error: outputContext.error }); |
| 3256 | if (deprecatedCallback) { |
| 3257 | helpInformation = deprecatedCallback(helpInformation); |
| 3258 | if (typeof helpInformation !== "string" && !Buffer.isBuffer(helpInformation)) { |
| 3259 | throw new Error("outputHelp callback must return a string or a Buffer"); |
| 3260 | } |
| 3261 | } |
| 3262 | outputContext.write(helpInformation); |
| 3263 | if (this._getHelpOption()?.long) { |
| 3264 | this.emit(this._getHelpOption().long); |
| 3265 | } |
| 3266 | this.emit("afterHelp", eventContext); |
| 3267 | this._getCommandAndAncestors().forEach( |
| 3268 | (command) => command.emit("afterAllHelp", eventContext) |
| 3269 | ); |
| 3270 | } |
| 3271 | /** |
| 3272 | * You can pass in flags and a description to customise the built-in help option. |
| 3273 | * Pass in false to disable the built-in help option. |
| 3274 | * |
| 3275 | * @example |
| 3276 | * program.helpOption('-?, --help' 'show help'); // customise |
| 3277 | * program.helpOption(false); // disable |
| 3278 | * |
| 3279 | * @param {(string | boolean)} flags |
| 3280 | * @param {string} [description] |
| 3281 | * @return {Command} `this` command for chaining |
| 3282 | */ |
| 3283 | helpOption(flags, description) { |
| 3284 | if (typeof flags === "boolean") { |
| 3285 | if (flags) { |
| 3286 | if (this._helpOption === null) this._helpOption = void 0; |
| 3287 | if (this._defaultOptionGroup) { |
| 3288 | this._initOptionGroup(this._getHelpOption()); |
| 3289 | } |
| 3290 | } else { |
| 3291 | this._helpOption = null; |
| 3292 | } |
| 3293 | return this; |
| 3294 | } |
| 3295 | this._helpOption = this.createOption( |
| 3296 | flags ?? "-h, --help", |
| 3297 | description ?? "display help for command" |
| 3298 | ); |
| 3299 | if (flags || description) this._initOptionGroup(this._helpOption); |
| 3300 | return this; |
| 3301 | } |
| 3302 | /** |
| 3303 | * Lazy create help option. |
| 3304 | * Returns null if has been disabled with .helpOption(false). |
| 3305 | * |
| 3306 | * @returns {(Option | null)} the help option |
| 3307 | * @package |
| 3308 | */ |
| 3309 | _getHelpOption() { |
| 3310 | if (this._helpOption === void 0) { |
| 3311 | this.helpOption(void 0, void 0); |
| 3312 | } |
| 3313 | return this._helpOption; |
| 3314 | } |
| 3315 | /** |
| 3316 | * Supply your own option to use for the built-in help option. |
| 3317 | * This is an alternative to using helpOption() to customise the flags and description etc. |
| 3318 | * |
| 3319 | * @param {Option} option |
| 3320 | * @return {Command} `this` command for chaining |
| 3321 | */ |
| 3322 | addHelpOption(option) { |
| 3323 | this._helpOption = option; |
| 3324 | this._initOptionGroup(option); |
| 3325 | return this; |
| 3326 | } |
| 3327 | /** |
| 3328 | * Output help information and exit. |
| 3329 | * |
| 3330 | * Outputs built-in help, and custom text added using `.addHelpText()`. |
| 3331 | * |
| 3332 | * @param {{ error: boolean }} [contextOptions] - pass {error:true} to write to stderr instead of stdout |
| 3333 | */ |
| 3334 | help(contextOptions) { |
| 3335 | this.outputHelp(contextOptions); |
| 3336 | let exitCode = Number(process2.exitCode ?? 0); |
| 3337 | if (exitCode === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) { |
| 3338 | exitCode = 1; |
| 3339 | } |
| 3340 | this._exit(exitCode, "commander.help", "(outputHelp)"); |
| 3341 | } |
| 3342 | /** |
| 3343 | * // Do a little typing to coordinate emit and listener for the help text events. |
| 3344 | * @typedef HelpTextEventContext |
| 3345 | * @type {object} |
| 3346 | * @property {boolean} error |
| 3347 | * @property {Command} command |
| 3348 | * @property {function} write |
| 3349 | */ |
| 3350 | /** |
| 3351 | * Add additional text to be displayed with the built-in help. |
| 3352 | * |
| 3353 | * Position is 'before' or 'after' to affect just this command, |
| 3354 | * and 'beforeAll' or 'afterAll' to affect this command and all its subcommands. |
| 3355 | * |
| 3356 | * @param {string} position - before or after built-in help |
| 3357 | * @param {(string | Function)} text - string to add, or a function returning a string |
| 3358 | * @return {Command} `this` command for chaining |
| 3359 | */ |
| 3360 | addHelpText(position, text) { |
| 3361 | const allowedValues = ["beforeAll", "before", "after", "afterAll"]; |
| 3362 | if (!allowedValues.includes(position)) { |
| 3363 | throw new Error(`Unexpected value for position to addHelpText. |
| 3364 | Expecting one of '${allowedValues.join("', '")}'`); |
| 3365 | } |
| 3366 | const helpEvent = `${position}Help`; |
| 3367 | this.on(helpEvent, (context) => { |
| 3368 | let helpStr; |
| 3369 | if (typeof text === "function") { |
| 3370 | helpStr = text({ error: context.error, command: context.command }); |
| 3371 | } else { |
| 3372 | helpStr = text; |
| 3373 | } |
| 3374 | if (helpStr) { |
| 3375 | context.write(`${helpStr} |
| 3376 | `); |
| 3377 | } |
| 3378 | }); |
| 3379 | return this; |
| 3380 | } |
| 3381 | /** |
| 3382 | * Output help information if help flags specified |
| 3383 | * |
| 3384 | * @param {Array} args - array of options to search for help flags |
| 3385 | * @private |
| 3386 | */ |
| 3387 | _outputHelpIfRequested(args) { |
| 3388 | const helpOption = this._getHelpOption(); |
| 3389 | const helpRequested = helpOption && args.find((arg) => helpOption.is(arg)); |
| 3390 | if (helpRequested) { |
| 3391 | this.outputHelp(); |
| 3392 | this._exit(0, "commander.helpDisplayed", "(outputHelp)"); |
| 3393 | } |
| 3394 | } |
| 3395 | }; |
| 3396 | function incrementNodeInspectorPort(args) { |
| 3397 | return args.map((arg) => { |
| 3398 | if (!arg.startsWith("--inspect")) { |
| 3399 | return arg; |
| 3400 | } |
| 3401 | let debugOption; |
| 3402 | let debugHost = "127.0.0.1"; |
| 3403 | let debugPort = "9229"; |
| 3404 | let match; |
| 3405 | if ((match = arg.match(/^(--inspect(-brk)?)$/)) !== null) { |
| 3406 | debugOption = match[1]; |
| 3407 | } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+)$/)) !== null) { |
| 3408 | debugOption = match[1]; |
| 3409 | if (/^\d+$/.test(match[3])) { |
| 3410 | debugPort = match[3]; |
| 3411 | } else { |
| 3412 | debugHost = match[3]; |
| 3413 | } |
| 3414 | } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+):(\d+)$/)) !== null) { |
| 3415 | debugOption = match[1]; |
| 3416 | debugHost = match[3]; |
| 3417 | debugPort = match[4]; |
| 3418 | } |
| 3419 | if (debugOption && debugPort !== "0") { |
| 3420 | return `${debugOption}=${debugHost}:${parseInt(debugPort) + 1}`; |
| 3421 | } |
| 3422 | return arg; |
| 3423 | }); |
| 3424 | } |
| 3425 | function useColor() { |
| 3426 | if (process2.env.NO_COLOR || process2.env.FORCE_COLOR === "0" || process2.env.FORCE_COLOR === "false") |
| 3427 | return false; |
| 3428 | if (process2.env.FORCE_COLOR || process2.env.CLICOLOR_FORCE !== void 0) |
| 3429 | return true; |
| 3430 | return void 0; |
| 3431 | } |
| 3432 | exports2.Command = Command2; |
| 3433 | exports2.useColor = useColor; |
| 3434 | } |
| 3435 | }); |
| 3436 | |
| 3437 | // node_modules/.pnpm/commander@14.0.1/node_modules/commander/index.js |
| 3438 | var require_commander = __commonJS({ |
| 3439 | "node_modules/.pnpm/commander@14.0.1/node_modules/commander/index.js"(exports2) { |
| 3440 | var { Argument: Argument2 } = require_argument(); |
| 3441 | var { Command: Command2 } = require_command(); |
| 3442 | var { CommanderError: CommanderError2, InvalidArgumentError: InvalidArgumentError2 } = require_error(); |
| 3443 | var { Help: Help2 } = require_help(); |
| 3444 | var { Option: Option2 } = require_option(); |
| 3445 | exports2.program = new Command2(); |
| 3446 | exports2.createCommand = (name) => new Command2(name); |
| 3447 | exports2.createOption = (flags, description) => new Option2(flags, description); |
| 3448 | exports2.createArgument = (name, description) => new Argument2(name, description); |
| 3449 | exports2.Command = Command2; |
| 3450 | exports2.Option = Option2; |
| 3451 | exports2.Argument = Argument2; |
| 3452 | exports2.Help = Help2; |
| 3453 | exports2.CommanderError = CommanderError2; |
| 3454 | exports2.InvalidArgumentError = InvalidArgumentError2; |
| 3455 | exports2.InvalidOptionArgumentError = InvalidArgumentError2; |
| 3456 | } |
| 3457 | }); |
| 3458 | |
| 3459 | // node_modules/.pnpm/@actions+core@1.11.1/node_modules/@actions/core/lib/utils.js |
| 3460 | var require_utils = __commonJS({ |
| 3461 | "node_modules/.pnpm/@actions+core@1.11.1/node_modules/@actions/core/lib/utils.js"(exports2) { |
| 3462 | "use strict"; |
| 3463 | Object.defineProperty(exports2, "__esModule", { value: true }); |
| 3464 | exports2.toCommandProperties = exports2.toCommandValue = void 0; |
| 3465 | function toCommandValue(input) { |
| 3466 | if (input === null || input === void 0) { |
| 3467 | return ""; |
| 3468 | } else if (typeof input === "string" || input instanceof String) { |
| 3469 | return input; |
| 3470 | } |
| 3471 | return JSON.stringify(input); |
| 3472 | } |
| 3473 | exports2.toCommandValue = toCommandValue; |
| 3474 | function toCommandProperties(annotationProperties) { |
| 3475 | if (!Object.keys(annotationProperties).length) { |
| 3476 | return {}; |
| 3477 | } |
| 3478 | return { |
| 3479 | title: annotationProperties.title, |
| 3480 | file: annotationProperties.file, |
| 3481 | line: annotationProperties.startLine, |
| 3482 | endLine: annotationProperties.endLine, |
| 3483 | col: annotationProperties.startColumn, |
| 3484 | endColumn: annotationProperties.endColumn |
| 3485 | }; |
| 3486 | } |
| 3487 | exports2.toCommandProperties = toCommandProperties; |
| 3488 | } |
| 3489 | }); |
| 3490 | |
| 3491 | // node_modules/.pnpm/@actions+core@1.11.1/node_modules/@actions/core/lib/command.js |
| 3492 | var require_command2 = __commonJS({ |
| 3493 | "node_modules/.pnpm/@actions+core@1.11.1/node_modules/@actions/core/lib/command.js"(exports2) { |
| 3494 | "use strict"; |
| 3495 | var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { |
| 3496 | if (k2 === void 0) k2 = k; |
| 3497 | var desc = Object.getOwnPropertyDescriptor(m, k); |
| 3498 | if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { |
| 3499 | desc = { enumerable: true, get: function() { |
| 3500 | return m[k]; |
| 3501 | } }; |
| 3502 | } |
| 3503 | Object.defineProperty(o, k2, desc); |
| 3504 | } : function(o, m, k, k2) { |
| 3505 | if (k2 === void 0) k2 = k; |
| 3506 | o[k2] = m[k]; |
| 3507 | }); |
| 3508 | var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { |
| 3509 | Object.defineProperty(o, "default", { enumerable: true, value: v }); |
| 3510 | } : function(o, v) { |
| 3511 | o["default"] = v; |
| 3512 | }); |
| 3513 | var __importStar = exports2 && exports2.__importStar || function(mod) { |
| 3514 | if (mod && mod.__esModule) return mod; |
| 3515 | var result = {}; |
| 3516 | if (mod != null) { |
| 3517 | for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); |
| 3518 | } |
| 3519 | __setModuleDefault(result, mod); |
| 3520 | return result; |
| 3521 | }; |
| 3522 | Object.defineProperty(exports2, "__esModule", { value: true }); |
| 3523 | exports2.issue = exports2.issueCommand = void 0; |
| 3524 | var os3 = __importStar(require("os")); |
| 3525 | var utils_1 = require_utils(); |
| 3526 | function issueCommand(command, properties, message) { |
| 3527 | const cmd = new Command2(command, properties, message); |
| 3528 | process.stdout.write(cmd.toString() + os3.EOL); |
| 3529 | } |
| 3530 | exports2.issueCommand = issueCommand; |
| 3531 | function issue(name, message = "") { |
| 3532 | issueCommand(name, {}, message); |
| 3533 | } |
| 3534 | exports2.issue = issue; |
| 3535 | var CMD_STRING = "::"; |
| 3536 | var Command2 = class { |
| 3537 | constructor(command, properties, message) { |
| 3538 | if (!command) { |
| 3539 | command = "missing.command"; |
| 3540 | } |
| 3541 | this.command = command; |
| 3542 | this.properties = properties; |
| 3543 | this.message = message; |
| 3544 | } |
| 3545 | toString() { |
| 3546 | let cmdStr = CMD_STRING + this.command; |
| 3547 | if (this.properties && Object.keys(this.properties).length > 0) { |
| 3548 | cmdStr += " "; |
| 3549 | let first = true; |
| 3550 | for (const key in this.properties) { |
| 3551 | if (this.properties.hasOwnProperty(key)) { |
| 3552 | const val = this.properties[key]; |
| 3553 | if (val) { |
| 3554 | if (first) { |
| 3555 | first = false; |
| 3556 | } else { |
| 3557 | cmdStr += ","; |
| 3558 | } |
| 3559 | cmdStr += `${key}=${escapeProperty(val)}`; |
| 3560 | } |
| 3561 | } |
| 3562 | } |
| 3563 | } |
| 3564 | cmdStr += `${CMD_STRING}${escapeData(this.message)}`; |
| 3565 | return cmdStr; |
| 3566 | } |
| 3567 | }; |
| 3568 | function escapeData(s) { |
| 3569 | return (0, utils_1.toCommandValue)(s).replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A"); |
| 3570 | } |
| 3571 | function escapeProperty(s) { |
| 3572 | return (0, utils_1.toCommandValue)(s).replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A").replace(/:/g, "%3A").replace(/,/g, "%2C"); |
| 3573 | } |
| 3574 | } |
| 3575 | }); |
| 3576 | |
| 3577 | // node_modules/.pnpm/@actions+core@1.11.1/node_modules/@actions/core/lib/file-command.js |
| 3578 | var require_file_command = __commonJS({ |
| 3579 | "node_modules/.pnpm/@actions+core@1.11.1/node_modules/@actions/core/lib/file-command.js"(exports2) { |
| 3580 | "use strict"; |
| 3581 | var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { |
| 3582 | if (k2 === void 0) k2 = k; |
| 3583 | var desc = Object.getOwnPropertyDescriptor(m, k); |
| 3584 | if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { |
| 3585 | desc = { enumerable: true, get: function() { |
| 3586 | return m[k]; |
| 3587 | } }; |
| 3588 | } |
| 3589 | Object.defineProperty(o, k2, desc); |
| 3590 | } : function(o, m, k, k2) { |
| 3591 | if (k2 === void 0) k2 = k; |
| 3592 | o[k2] = m[k]; |
| 3593 | }); |
| 3594 | var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { |
| 3595 | Object.defineProperty(o, "default", { enumerable: true, value: v }); |
| 3596 | } : function(o, v) { |
| 3597 | o["default"] = v; |
| 3598 | }); |
| 3599 | var __importStar = exports2 && exports2.__importStar || function(mod) { |
| 3600 | if (mod && mod.__esModule) return mod; |
| 3601 | var result = {}; |
| 3602 | if (mod != null) { |
| 3603 | for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); |
| 3604 | } |
| 3605 | __setModuleDefault(result, mod); |
| 3606 | return result; |
| 3607 | }; |
| 3608 | Object.defineProperty(exports2, "__esModule", { value: true }); |
| 3609 | exports2.prepareKeyValueMessage = exports2.issueFileCommand = void 0; |
| 3610 | var crypto = __importStar(require("crypto")); |
| 3611 | var fs5 = __importStar(require("fs")); |
| 3612 | var os3 = __importStar(require("os")); |
| 3613 | var utils_1 = require_utils(); |
| 3614 | function issueFileCommand(command, message) { |
| 3615 | const filePath = process.env[`GITHUB_${command}`]; |
| 3616 | if (!filePath) { |
| 3617 | throw new Error(`Unable to find environment variable for file command ${command}`); |
| 3618 | } |
| 3619 | if (!fs5.existsSync(filePath)) { |
| 3620 | throw new Error(`Missing file at path: ${filePath}`); |
| 3621 | } |
| 3622 | fs5.appendFileSync(filePath, `${(0, utils_1.toCommandValue)(message)}${os3.EOL}`, { |
| 3623 | encoding: "utf8" |
| 3624 | }); |
| 3625 | } |
| 3626 | exports2.issueFileCommand = issueFileCommand; |
| 3627 | function prepareKeyValueMessage(key, value) { |
| 3628 | const delimiter = `ghadelimiter_${crypto.randomUUID()}`; |
| 3629 | const convertedValue = (0, utils_1.toCommandValue)(value); |
| 3630 | if (key.includes(delimiter)) { |
| 3631 | throw new Error(`Unexpected input: name should not contain the delimiter "${delimiter}"`); |
| 3632 | } |
| 3633 | if (convertedValue.includes(delimiter)) { |
| 3634 | throw new Error(`Unexpected input: value should not contain the delimiter "${delimiter}"`); |
| 3635 | } |
| 3636 | return `${key}<<${delimiter}${os3.EOL}${convertedValue}${os3.EOL}${delimiter}`; |
| 3637 | } |
| 3638 | exports2.prepareKeyValueMessage = prepareKeyValueMessage; |
| 3639 | } |
| 3640 | }); |
| 3641 | |
| 3642 | // node_modules/.pnpm/@actions+http-client@2.2.3/node_modules/@actions/http-client/lib/proxy.js |
| 3643 | var require_proxy = __commonJS({ |
| 3644 | "node_modules/.pnpm/@actions+http-client@2.2.3/node_modules/@actions/http-client/lib/proxy.js"(exports2) { |
| 3645 | "use strict"; |
| 3646 | Object.defineProperty(exports2, "__esModule", { value: true }); |
| 3647 | exports2.checkBypass = exports2.getProxyUrl = void 0; |
| 3648 | function getProxyUrl(reqUrl) { |
| 3649 | const usingSsl = reqUrl.protocol === "https:"; |
| 3650 | if (checkBypass(reqUrl)) { |
| 3651 | return void 0; |
| 3652 | } |
| 3653 | const proxyVar = (() => { |
| 3654 | if (usingSsl) { |
| 3655 | return process.env["https_proxy"] || process.env["HTTPS_PROXY"]; |
| 3656 | } else { |
| 3657 | return process.env["http_proxy"] || process.env["HTTP_PROXY"]; |
| 3658 | } |
| 3659 | })(); |
| 3660 | if (proxyVar) { |
| 3661 | try { |
| 3662 | return new DecodedURL(proxyVar); |
| 3663 | } catch (_a) { |
| 3664 | if (!proxyVar.startsWith("http://") && !proxyVar.startsWith("https://")) |
| 3665 | return new DecodedURL(`http://${proxyVar}`); |
| 3666 | } |
| 3667 | } else { |
| 3668 | return void 0; |
| 3669 | } |
| 3670 | } |
| 3671 | exports2.getProxyUrl = getProxyUrl; |
| 3672 | function checkBypass(reqUrl) { |
| 3673 | if (!reqUrl.hostname) { |
| 3674 | return false; |
| 3675 | } |
| 3676 | const reqHost = reqUrl.hostname; |
| 3677 | if (isLoopbackAddress(reqHost)) { |
| 3678 | return true; |
| 3679 | } |
| 3680 | const noProxy = process.env["no_proxy"] || process.env["NO_PROXY"] || ""; |
| 3681 | if (!noProxy) { |
| 3682 | return false; |
| 3683 | } |
| 3684 | let reqPort; |
| 3685 | if (reqUrl.port) { |
| 3686 | reqPort = Number(reqUrl.port); |
| 3687 | } else if (reqUrl.protocol === "http:") { |
| 3688 | reqPort = 80; |
| 3689 | } else if (reqUrl.protocol === "https:") { |
| 3690 | reqPort = 443; |
| 3691 | } |
| 3692 | const upperReqHosts = [reqUrl.hostname.toUpperCase()]; |
| 3693 | if (typeof reqPort === "number") { |
| 3694 | upperReqHosts.push(`${upperReqHosts[0]}:${reqPort}`); |
| 3695 | } |
| 3696 | for (const upperNoProxyItem of noProxy.split(",").map((x) => x.trim().toUpperCase()).filter((x) => x)) { |
| 3697 | if (upperNoProxyItem === "*" || upperReqHosts.some((x) => x === upperNoProxyItem || x.endsWith(`.${upperNoProxyItem}`) || upperNoProxyItem.startsWith(".") && x.endsWith(`${upperNoProxyItem}`))) { |
| 3698 | return true; |
| 3699 | } |
| 3700 | } |
| 3701 | return false; |
| 3702 | } |
| 3703 | exports2.checkBypass = checkBypass; |
| 3704 | function isLoopbackAddress(host) { |
| 3705 | const hostLower = host.toLowerCase(); |
| 3706 | return hostLower === "localhost" || hostLower.startsWith("127.") || hostLower.startsWith("[::1]") || hostLower.startsWith("[0:0:0:0:0:0:0:1]"); |
| 3707 | } |
| 3708 | var DecodedURL = class extends URL { |
| 3709 | constructor(url, base) { |
| 3710 | super(url, base); |
| 3711 | this._decodedUsername = decodeURIComponent(super.username); |
| 3712 | this._decodedPassword = decodeURIComponent(super.password); |
| 3713 | } |
| 3714 | get username() { |
| 3715 | return this._decodedUsername; |
| 3716 | } |
| 3717 | get password() { |
| 3718 | return this._decodedPassword; |
| 3719 | } |
| 3720 | }; |
| 3721 | } |
| 3722 | }); |
| 3723 | |
| 3724 | // node_modules/.pnpm/tunnel@0.0.6/node_modules/tunnel/lib/tunnel.js |
| 3725 | var require_tunnel = __commonJS({ |
| 3726 | "node_modules/.pnpm/tunnel@0.0.6/node_modules/tunnel/lib/tunnel.js"(exports2) { |
| 3727 | "use strict"; |
| 3728 | var net = require("net"); |
| 3729 | var tls = require("tls"); |
| 3730 | var http = require("http"); |
| 3731 | var https = require("https"); |
| 3732 | var events = require("events"); |
| 3733 | var assert = require("assert"); |
| 3734 | var util = require("util"); |
| 3735 | exports2.httpOverHttp = httpOverHttp; |
| 3736 | exports2.httpsOverHttp = httpsOverHttp; |
| 3737 | exports2.httpOverHttps = httpOverHttps; |
| 3738 | exports2.httpsOverHttps = httpsOverHttps; |
| 3739 | function httpOverHttp(options) { |
| 3740 | var agent = new TunnelingAgent(options); |
| 3741 | agent.request = http.request; |
| 3742 | return agent; |
| 3743 | } |
| 3744 | function httpsOverHttp(options) { |
| 3745 | var agent = new TunnelingAgent(options); |
| 3746 | agent.request = http.request; |
| 3747 | agent.createSocket = createSecureSocket; |
| 3748 | agent.defaultPort = 443; |
| 3749 | return agent; |
| 3750 | } |
| 3751 | function httpOverHttps(options) { |
| 3752 | var agent = new TunnelingAgent(options); |
| 3753 | agent.request = https.request; |
| 3754 | return agent; |
| 3755 | } |
| 3756 | function httpsOverHttps(options) { |
| 3757 | var agent = new TunnelingAgent(options); |
| 3758 | agent.request = https.request; |
| 3759 | agent.createSocket = createSecureSocket; |
| 3760 | agent.defaultPort = 443; |
| 3761 | return agent; |
| 3762 | } |
| 3763 | function TunnelingAgent(options) { |
| 3764 | var self = this; |
| 3765 | self.options = options || {}; |
| 3766 | self.proxyOptions = self.options.proxy || {}; |
| 3767 | self.maxSockets = self.options.maxSockets || http.Agent.defaultMaxSockets; |
| 3768 | self.requests = []; |
| 3769 | self.sockets = []; |
| 3770 | self.on("free", function onFree(socket, host, port, localAddress) { |
| 3771 | var options2 = toOptions(host, port, localAddress); |
| 3772 | for (var i = 0, len = self.requests.length; i < len; ++i) { |
| 3773 | var pending = self.requests[i]; |
| 3774 | if (pending.host === options2.host && pending.port === options2.port) { |
| 3775 | self.requests.splice(i, 1); |
| 3776 | pending.request.onSocket(socket); |
| 3777 | return; |
| 3778 | } |
| 3779 | } |
| 3780 | socket.destroy(); |
| 3781 | self.removeSocket(socket); |
| 3782 | }); |
| 3783 | } |
| 3784 | util.inherits(TunnelingAgent, events.EventEmitter); |
| 3785 | TunnelingAgent.prototype.addRequest = function addRequest(req, host, port, localAddress) { |
| 3786 | var self = this; |
| 3787 | var options = mergeOptions({ request: req }, self.options, toOptions(host, port, localAddress)); |
| 3788 | if (self.sockets.length >= this.maxSockets) { |
| 3789 | self.requests.push(options); |
| 3790 | return; |
| 3791 | } |
| 3792 | self.createSocket(options, function(socket) { |
| 3793 | socket.on("free", onFree); |
| 3794 | socket.on("close", onCloseOrRemove); |
| 3795 | socket.on("agentRemove", onCloseOrRemove); |
| 3796 | req.onSocket(socket); |
| 3797 | function onFree() { |
| 3798 | self.emit("free", socket, options); |
| 3799 | } |
| 3800 | function onCloseOrRemove(err) { |
| 3801 | self.removeSocket(socket); |
| 3802 | socket.removeListener("free", onFree); |
| 3803 | socket.removeListener("close", onCloseOrRemove); |
| 3804 | socket.removeListener("agentRemove", onCloseOrRemove); |
| 3805 | } |
| 3806 | }); |
| 3807 | }; |
| 3808 | TunnelingAgent.prototype.createSocket = function createSocket(options, cb) { |
| 3809 | var self = this; |
| 3810 | var placeholder = {}; |
| 3811 | self.sockets.push(placeholder); |
| 3812 | var connectOptions = mergeOptions({}, self.proxyOptions, { |
| 3813 | method: "CONNECT", |
| 3814 | path: options.host + ":" + options.port, |
| 3815 | agent: false, |
| 3816 | headers: { |
| 3817 | host: options.host + ":" + options.port |
| 3818 | } |
| 3819 | }); |
| 3820 | if (options.localAddress) { |
| 3821 | connectOptions.localAddress = options.localAddress; |
| 3822 | } |
| 3823 | if (connectOptions.proxyAuth) { |
| 3824 | connectOptions.headers = connectOptions.headers || {}; |
| 3825 | connectOptions.headers["Proxy-Authorization"] = "Basic " + new Buffer(connectOptions.proxyAuth).toString("base64"); |
| 3826 | } |
| 3827 | debug("making CONNECT request"); |
| 3828 | var connectReq = self.request(connectOptions); |
| 3829 | connectReq.useChunkedEncodingByDefault = false; |
| 3830 | connectReq.once("response", onResponse); |
| 3831 | connectReq.once("upgrade", onUpgrade); |
| 3832 | connectReq.once("connect", onConnect); |
| 3833 | connectReq.once("error", onError); |
| 3834 | connectReq.end(); |
| 3835 | function onResponse(res) { |
| 3836 | res.upgrade = true; |
| 3837 | } |
| 3838 | function onUpgrade(res, socket, head) { |
| 3839 | process.nextTick(function() { |
| 3840 | onConnect(res, socket, head); |
| 3841 | }); |
| 3842 | } |
| 3843 | function onConnect(res, socket, head) { |
| 3844 | connectReq.removeAllListeners(); |
| 3845 | socket.removeAllListeners(); |
| 3846 | if (res.statusCode !== 200) { |
| 3847 | debug( |
| 3848 | "tunneling socket could not be established, statusCode=%d", |
| 3849 | res.statusCode |
| 3850 | ); |
| 3851 | socket.destroy(); |
| 3852 | var error = new Error("tunneling socket could not be established, statusCode=" + res.statusCode); |
| 3853 | error.code = "ECONNRESET"; |
| 3854 | options.request.emit("error", error); |
| 3855 | self.removeSocket(placeholder); |
| 3856 | return; |
| 3857 | } |
| 3858 | if (head.length > 0) { |
| 3859 | debug("got illegal response body from proxy"); |
| 3860 | socket.destroy(); |
| 3861 | var error = new Error("got illegal response body from proxy"); |
| 3862 | error.code = "ECONNRESET"; |
| 3863 | options.request.emit("error", error); |
| 3864 | self.removeSocket(placeholder); |
| 3865 | return; |
| 3866 | } |
| 3867 | debug("tunneling connection has established"); |
| 3868 | self.sockets[self.sockets.indexOf(placeholder)] = socket; |
| 3869 | return cb(socket); |
| 3870 | } |
| 3871 | function onError(cause) { |
| 3872 | connectReq.removeAllListeners(); |
| 3873 | debug( |
| 3874 | "tunneling socket could not be established, cause=%s\n", |
| 3875 | cause.message, |
| 3876 | cause.stack |
| 3877 | ); |
| 3878 | var error = new Error("tunneling socket could not be established, cause=" + cause.message); |
| 3879 | error.code = "ECONNRESET"; |
| 3880 | options.request.emit("error", error); |
| 3881 | self.removeSocket(placeholder); |
| 3882 | } |
| 3883 | }; |
| 3884 | TunnelingAgent.prototype.removeSocket = function removeSocket(socket) { |
| 3885 | var pos = this.sockets.indexOf(socket); |
| 3886 | if (pos === -1) { |
| 3887 | return; |
| 3888 | } |
| 3889 | this.sockets.splice(pos, 1); |
| 3890 | var pending = this.requests.shift(); |
| 3891 | if (pending) { |
| 3892 | this.createSocket(pending, function(socket2) { |
| 3893 | pending.request.onSocket(socket2); |
| 3894 | }); |
| 3895 | } |
| 3896 | }; |
| 3897 | function createSecureSocket(options, cb) { |
| 3898 | var self = this; |
| 3899 | TunnelingAgent.prototype.createSocket.call(self, options, function(socket) { |
| 3900 | var hostHeader = options.request.getHeader("host"); |
| 3901 | var tlsOptions = mergeOptions({}, self.options, { |
| 3902 | socket, |
| 3903 | servername: hostHeader ? hostHeader.replace(/:.*$/, "") : options.host |
| 3904 | }); |
| 3905 | var secureSocket = tls.connect(0, tlsOptions); |
| 3906 | self.sockets[self.sockets.indexOf(socket)] = secureSocket; |
| 3907 | cb(secureSocket); |
| 3908 | }); |
| 3909 | } |
| 3910 | function toOptions(host, port, localAddress) { |
| 3911 | if (typeof host === "string") { |
| 3912 | return { |
| 3913 | host, |
| 3914 | port, |
| 3915 | localAddress |
| 3916 | }; |
| 3917 | } |
| 3918 | return host; |
| 3919 | } |
| 3920 | function mergeOptions(target) { |
| 3921 | for (var i = 1, len = arguments.length; i < len; ++i) { |
| 3922 | var overrides = arguments[i]; |
| 3923 | if (typeof overrides === "object") { |
| 3924 | var keys = Object.keys(overrides); |
| 3925 | for (var j = 0, keyLen = keys.length; j < keyLen; ++j) { |
| 3926 | var k = keys[j]; |
| 3927 | if (overrides[k] !== void 0) { |
| 3928 | target[k] = overrides[k]; |
| 3929 | } |
| 3930 | } |
| 3931 | } |
| 3932 | } |
| 3933 | return target; |
| 3934 | } |
| 3935 | var debug; |
| 3936 | if (process.env.NODE_DEBUG && /\btunnel\b/.test(process.env.NODE_DEBUG)) { |
| 3937 | debug = function() { |
| 3938 | var args = Array.prototype.slice.call(arguments); |
| 3939 | if (typeof args[0] === "string") { |
| 3940 | args[0] = "TUNNEL: " + args[0]; |
| 3941 | } else { |
| 3942 | args.unshift("TUNNEL:"); |
| 3943 | } |
| 3944 | console.error.apply(console, args); |
| 3945 | }; |
| 3946 | } else { |
| 3947 | debug = function() { |
| 3948 | }; |
| 3949 | } |
| 3950 | exports2.debug = debug; |
| 3951 | } |
| 3952 | }); |
| 3953 | |
| 3954 | // node_modules/.pnpm/tunnel@0.0.6/node_modules/tunnel/index.js |
| 3955 | var require_tunnel2 = __commonJS({ |
| 3956 | "node_modules/.pnpm/tunnel@0.0.6/node_modules/tunnel/index.js"(exports2, module2) { |
| 3957 | module2.exports = require_tunnel(); |
| 3958 | } |
| 3959 | }); |
| 3960 | |
| 3961 | // node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/core/symbols.js |
| 3962 | var require_symbols = __commonJS({ |
| 3963 | "node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/core/symbols.js"(exports2, module2) { |
| 3964 | module2.exports = { |
| 3965 | kClose: Symbol("close"), |
| 3966 | kDestroy: Symbol("destroy"), |
| 3967 | kDispatch: Symbol("dispatch"), |
| 3968 | kUrl: Symbol("url"), |
| 3969 | kWriting: Symbol("writing"), |
| 3970 | kResuming: Symbol("resuming"), |
| 3971 | kQueue: Symbol("queue"), |
| 3972 | kConnect: Symbol("connect"), |
| 3973 | kConnecting: Symbol("connecting"), |
| 3974 | kHeadersList: Symbol("headers list"), |
| 3975 | kKeepAliveDefaultTimeout: Symbol("default keep alive timeout"), |
| 3976 | kKeepAliveMaxTimeout: Symbol("max keep alive timeout"), |
| 3977 | kKeepAliveTimeoutThreshold: Symbol("keep alive timeout threshold"), |
| 3978 | kKeepAliveTimeoutValue: Symbol("keep alive timeout"), |
| 3979 | kKeepAlive: Symbol("keep alive"), |
| 3980 | kHeadersTimeout: Symbol("headers timeout"), |
| 3981 | kBodyTimeout: Symbol("body timeout"), |
| 3982 | kServerName: Symbol("server name"), |
| 3983 | kLocalAddress: Symbol("local address"), |
| 3984 | kHost: Symbol("host"), |
| 3985 | kNoRef: Symbol("no ref"), |
| 3986 | kBodyUsed: Symbol("used"), |
| 3987 | kRunning: Symbol("running"), |
| 3988 | kBlocking: Symbol("blocking"), |
| 3989 | kPending: Symbol("pending"), |
| 3990 | kSize: Symbol("size"), |
| 3991 | kBusy: Symbol("busy"), |
| 3992 | kQueued: Symbol("queued"), |
| 3993 | kFree: Symbol("free"), |
| 3994 | kConnected: Symbol("connected"), |
| 3995 | kClosed: Symbol("closed"), |
| 3996 | kNeedDrain: Symbol("need drain"), |
| 3997 | kReset: Symbol("reset"), |
| 3998 | kDestroyed: Symbol.for("nodejs.stream.destroyed"), |
| 3999 | kMaxHeadersSize: Symbol("max headers size"), |
| 4000 | kRunningIdx: Symbol("running index"), |
| 4001 | kPendingIdx: Symbol("pending index"), |
| 4002 | kError: Symbol("error"), |
| 4003 | kClients: Symbol("clients"), |
| 4004 | kClient: Symbol("client"), |
| 4005 | kParser: Symbol("parser"), |
| 4006 | kOnDestroyed: Symbol("destroy callbacks"), |
| 4007 | kPipelining: Symbol("pipelining"), |
| 4008 | kSocket: Symbol("socket"), |
| 4009 | kHostHeader: Symbol("host header"), |
| 4010 | kConnector: Symbol("connector"), |
| 4011 | kStrictContentLength: Symbol("strict content length"), |
| 4012 | kMaxRedirections: Symbol("maxRedirections"), |
| 4013 | kMaxRequests: Symbol("maxRequestsPerClient"), |
| 4014 | kProxy: Symbol("proxy agent options"), |
| 4015 | kCounter: Symbol("socket request counter"), |
| 4016 | kInterceptors: Symbol("dispatch interceptors"), |
| 4017 | kMaxResponseSize: Symbol("max response size"), |
| 4018 | kHTTP2Session: Symbol("http2Session"), |
| 4019 | kHTTP2SessionState: Symbol("http2Session state"), |
| 4020 | kHTTP2BuildRequest: Symbol("http2 build request"), |
| 4021 | kHTTP1BuildRequest: Symbol("http1 build request"), |
| 4022 | kHTTP2CopyHeaders: Symbol("http2 copy headers"), |
| 4023 | kHTTPConnVersion: Symbol("http connection version"), |
| 4024 | kRetryHandlerDefaultRetry: Symbol("retry agent default retry"), |
| 4025 | kConstruct: Symbol("constructable") |
| 4026 | }; |
| 4027 | } |
| 4028 | }); |
| 4029 | |
| 4030 | // node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/core/errors.js |
| 4031 | var require_errors = __commonJS({ |
| 4032 | "node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/core/errors.js"(exports2, module2) { |
| 4033 | "use strict"; |
| 4034 | var UndiciError = class extends Error { |
| 4035 | constructor(message) { |
| 4036 | super(message); |
| 4037 | this.name = "UndiciError"; |
| 4038 | this.code = "UND_ERR"; |
| 4039 | } |
| 4040 | }; |
| 4041 | var ConnectTimeoutError = class _ConnectTimeoutError extends UndiciError { |
| 4042 | constructor(message) { |
| 4043 | super(message); |
| 4044 | Error.captureStackTrace(this, _ConnectTimeoutError); |
| 4045 | this.name = "ConnectTimeoutError"; |
| 4046 | this.message = message || "Connect Timeout Error"; |
| 4047 | this.code = "UND_ERR_CONNECT_TIMEOUT"; |
| 4048 | } |
| 4049 | }; |
| 4050 | var HeadersTimeoutError = class _HeadersTimeoutError extends UndiciError { |
| 4051 | constructor(message) { |
| 4052 | super(message); |
| 4053 | Error.captureStackTrace(this, _HeadersTimeoutError); |
| 4054 | this.name = "HeadersTimeoutError"; |
| 4055 | this.message = message || "Headers Timeout Error"; |
| 4056 | this.code = "UND_ERR_HEADERS_TIMEOUT"; |
| 4057 | } |
| 4058 | }; |
| 4059 | var HeadersOverflowError = class _HeadersOverflowError extends UndiciError { |
| 4060 | constructor(message) { |
| 4061 | super(message); |
| 4062 | Error.captureStackTrace(this, _HeadersOverflowError); |
| 4063 | this.name = "HeadersOverflowError"; |
| 4064 | this.message = message || "Headers Overflow Error"; |
| 4065 | this.code = "UND_ERR_HEADERS_OVERFLOW"; |
| 4066 | } |
| 4067 | }; |
| 4068 | var BodyTimeoutError = class _BodyTimeoutError extends UndiciError { |
| 4069 | constructor(message) { |
| 4070 | super(message); |
| 4071 | Error.captureStackTrace(this, _BodyTimeoutError); |
| 4072 | this.name = "BodyTimeoutError"; |
| 4073 | this.message = message || "Body Timeout Error"; |
| 4074 | this.code = "UND_ERR_BODY_TIMEOUT"; |
| 4075 | } |
| 4076 | }; |
| 4077 | var ResponseStatusCodeError = class _ResponseStatusCodeError extends UndiciError { |
| 4078 | constructor(message, statusCode, headers, body) { |
| 4079 | super(message); |
| 4080 | Error.captureStackTrace(this, _ResponseStatusCodeError); |
| 4081 | this.name = "ResponseStatusCodeError"; |
| 4082 | this.message = message || "Response Status Code Error"; |
| 4083 | this.code = "UND_ERR_RESPONSE_STATUS_CODE"; |
| 4084 | this.body = body; |
| 4085 | this.status = statusCode; |
| 4086 | this.statusCode = statusCode; |
| 4087 | this.headers = headers; |
| 4088 | } |
| 4089 | }; |
| 4090 | var InvalidArgumentError2 = class _InvalidArgumentError extends UndiciError { |
| 4091 | constructor(message) { |
| 4092 | super(message); |
| 4093 | Error.captureStackTrace(this, _InvalidArgumentError); |
| 4094 | this.name = "InvalidArgumentError"; |
| 4095 | this.message = message || "Invalid Argument Error"; |
| 4096 | this.code = "UND_ERR_INVALID_ARG"; |
| 4097 | } |
| 4098 | }; |
| 4099 | var InvalidReturnValueError = class _InvalidReturnValueError extends UndiciError { |
| 4100 | constructor(message) { |
| 4101 | super(message); |
| 4102 | Error.captureStackTrace(this, _InvalidReturnValueError); |
| 4103 | this.name = "InvalidReturnValueError"; |
| 4104 | this.message = message || "Invalid Return Value Error"; |
| 4105 | this.code = "UND_ERR_INVALID_RETURN_VALUE"; |
| 4106 | } |
| 4107 | }; |
| 4108 | var RequestAbortedError = class _RequestAbortedError extends UndiciError { |
| 4109 | constructor(message) { |
| 4110 | super(message); |
| 4111 | Error.captureStackTrace(this, _RequestAbortedError); |
| 4112 | this.name = "AbortError"; |
| 4113 | this.message = message || "Request aborted"; |
| 4114 | this.code = "UND_ERR_ABORTED"; |
| 4115 | } |
| 4116 | }; |
| 4117 | var InformationalError = class _InformationalError extends UndiciError { |
| 4118 | constructor(message) { |
| 4119 | super(message); |
| 4120 | Error.captureStackTrace(this, _InformationalError); |
| 4121 | this.name = "InformationalError"; |
| 4122 | this.message = message || "Request information"; |
| 4123 | this.code = "UND_ERR_INFO"; |
| 4124 | } |
| 4125 | }; |
| 4126 | var RequestContentLengthMismatchError = class _RequestContentLengthMismatchError extends UndiciError { |
| 4127 | constructor(message) { |
| 4128 | super(message); |
| 4129 | Error.captureStackTrace(this, _RequestContentLengthMismatchError); |
| 4130 | this.name = "RequestContentLengthMismatchError"; |
| 4131 | this.message = message || "Request body length does not match content-length header"; |
| 4132 | this.code = "UND_ERR_REQ_CONTENT_LENGTH_MISMATCH"; |
| 4133 | } |
| 4134 | }; |
| 4135 | var ResponseContentLengthMismatchError = class _ResponseContentLengthMismatchError extends UndiciError { |
| 4136 | constructor(message) { |
| 4137 | super(message); |
| 4138 | Error.captureStackTrace(this, _ResponseContentLengthMismatchError); |
| 4139 | this.name = "ResponseContentLengthMismatchError"; |
| 4140 | this.message = message || "Response body length does not match content-length header"; |
| 4141 | this.code = "UND_ERR_RES_CONTENT_LENGTH_MISMATCH"; |
| 4142 | } |
| 4143 | }; |
| 4144 | var ClientDestroyedError = class _ClientDestroyedError extends UndiciError { |
| 4145 | constructor(message) { |
| 4146 | super(message); |
| 4147 | Error.captureStackTrace(this, _ClientDestroyedError); |
| 4148 | this.name = "ClientDestroyedError"; |
| 4149 | this.message = message || "The client is destroyed"; |
| 4150 | this.code = "UND_ERR_DESTROYED"; |
| 4151 | } |
| 4152 | }; |
| 4153 | var ClientClosedError = class _ClientClosedError extends UndiciError { |
| 4154 | constructor(message) { |
| 4155 | super(message); |
| 4156 | Error.captureStackTrace(this, _ClientClosedError); |
| 4157 | this.name = "ClientClosedError"; |
| 4158 | this.message = message || "The client is closed"; |
| 4159 | this.code = "UND_ERR_CLOSED"; |
| 4160 | } |
| 4161 | }; |
| 4162 | var SocketError = class _SocketError extends UndiciError { |
| 4163 | constructor(message, socket) { |
| 4164 | super(message); |
| 4165 | Error.captureStackTrace(this, _SocketError); |
| 4166 | this.name = "SocketError"; |
| 4167 | this.message = message || "Socket error"; |
| 4168 | this.code = "UND_ERR_SOCKET"; |
| 4169 | this.socket = socket; |
| 4170 | } |
| 4171 | }; |
| 4172 | var NotSupportedError = class _NotSupportedError extends UndiciError { |
| 4173 | constructor(message) { |
| 4174 | super(message); |
| 4175 | Error.captureStackTrace(this, _NotSupportedError); |
| 4176 | this.name = "NotSupportedError"; |
| 4177 | this.message = message || "Not supported error"; |
| 4178 | this.code = "UND_ERR_NOT_SUPPORTED"; |
| 4179 | } |
| 4180 | }; |
| 4181 | var BalancedPoolMissingUpstreamError = class extends UndiciError { |
| 4182 | constructor(message) { |
| 4183 | super(message); |
| 4184 | Error.captureStackTrace(this, NotSupportedError); |
| 4185 | this.name = "MissingUpstreamError"; |
| 4186 | this.message = message || "No upstream has been added to the BalancedPool"; |
| 4187 | this.code = "UND_ERR_BPL_MISSING_UPSTREAM"; |
| 4188 | } |
| 4189 | }; |
| 4190 | var HTTPParserError = class _HTTPParserError extends Error { |
| 4191 | constructor(message, code, data) { |
| 4192 | super(message); |
| 4193 | Error.captureStackTrace(this, _HTTPParserError); |
| 4194 | this.name = "HTTPParserError"; |
| 4195 | this.code = code ? `HPE_${code}` : void 0; |
| 4196 | this.data = data ? data.toString() : void 0; |
| 4197 | } |
| 4198 | }; |
| 4199 | var ResponseExceededMaxSizeError = class _ResponseExceededMaxSizeError extends UndiciError { |
| 4200 | constructor(message) { |
| 4201 | super(message); |
| 4202 | Error.captureStackTrace(this, _ResponseExceededMaxSizeError); |
| 4203 | this.name = "ResponseExceededMaxSizeError"; |
| 4204 | this.message = message || "Response content exceeded max size"; |
| 4205 | this.code = "UND_ERR_RES_EXCEEDED_MAX_SIZE"; |
| 4206 | } |
| 4207 | }; |
| 4208 | var RequestRetryError = class _RequestRetryError extends UndiciError { |
| 4209 | constructor(message, code, { headers, data }) { |
| 4210 | super(message); |
| 4211 | Error.captureStackTrace(this, _RequestRetryError); |
| 4212 | this.name = "RequestRetryError"; |
| 4213 | this.message = message || "Request retry error"; |
| 4214 | this.code = "UND_ERR_REQ_RETRY"; |
| 4215 | this.statusCode = code; |
| 4216 | this.data = data; |
| 4217 | this.headers = headers; |
| 4218 | } |
| 4219 | }; |
| 4220 | module2.exports = { |
| 4221 | HTTPParserError, |
| 4222 | UndiciError, |
| 4223 | HeadersTimeoutError, |
| 4224 | HeadersOverflowError, |
| 4225 | BodyTimeoutError, |
| 4226 | RequestContentLengthMismatchError, |
| 4227 | ConnectTimeoutError, |
| 4228 | ResponseStatusCodeError, |
| 4229 | InvalidArgumentError: InvalidArgumentError2, |
| 4230 | InvalidReturnValueError, |
| 4231 | RequestAbortedError, |
| 4232 | ClientDestroyedError, |
| 4233 | ClientClosedError, |
| 4234 | InformationalError, |
| 4235 | SocketError, |
| 4236 | NotSupportedError, |
| 4237 | ResponseContentLengthMismatchError, |
| 4238 | BalancedPoolMissingUpstreamError, |
| 4239 | ResponseExceededMaxSizeError, |
| 4240 | RequestRetryError |
| 4241 | }; |
| 4242 | } |
| 4243 | }); |
| 4244 | |
| 4245 | // node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/core/constants.js |
| 4246 | var require_constants = __commonJS({ |
| 4247 | "node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/core/constants.js"(exports2, module2) { |
| 4248 | "use strict"; |
| 4249 | var headerNameLowerCasedRecord = {}; |
| 4250 | var wellknownHeaderNames = [ |
| 4251 | "Accept", |
| 4252 | "Accept-Encoding", |
| 4253 | "Accept-Language", |
| 4254 | "Accept-Ranges", |
| 4255 | "Access-Control-Allow-Credentials", |
| 4256 | "Access-Control-Allow-Headers", |
| 4257 | "Access-Control-Allow-Methods", |
| 4258 | "Access-Control-Allow-Origin", |
| 4259 | "Access-Control-Expose-Headers", |
| 4260 | "Access-Control-Max-Age", |
| 4261 | "Access-Control-Request-Headers", |
| 4262 | "Access-Control-Request-Method", |
| 4263 | "Age", |
| 4264 | "Allow", |
| 4265 | "Alt-Svc", |
| 4266 | "Alt-Used", |
| 4267 | "Authorization", |
| 4268 | "Cache-Control", |
| 4269 | "Clear-Site-Data", |
| 4270 | "Connection", |
| 4271 | "Content-Disposition", |
| 4272 | "Content-Encoding", |
| 4273 | "Content-Language", |
| 4274 | "Content-Length", |
| 4275 | "Content-Location", |
| 4276 | "Content-Range", |
| 4277 | "Content-Security-Policy", |
| 4278 | "Content-Security-Policy-Report-Only", |
| 4279 | "Content-Type", |
| 4280 | "Cookie", |
| 4281 | "Cross-Origin-Embedder-Policy", |
| 4282 | "Cross-Origin-Opener-Policy", |
| 4283 | "Cross-Origin-Resource-Policy", |
| 4284 | "Date", |
| 4285 | "Device-Memory", |
| 4286 | "Downlink", |
| 4287 | "ECT", |
| 4288 | "ETag", |
| 4289 | "Expect", |
| 4290 | "Expect-CT", |
| 4291 | "Expires", |
| 4292 | "Forwarded", |
| 4293 | "From", |
| 4294 | "Host", |
| 4295 | "If-Match", |
| 4296 | "If-Modified-Since", |
| 4297 | "If-None-Match", |
| 4298 | "If-Range", |
| 4299 | "If-Unmodified-Since", |
| 4300 | "Keep-Alive", |
| 4301 | "Last-Modified", |
| 4302 | "Link", |
| 4303 | "Location", |
| 4304 | "Max-Forwards", |
| 4305 | "Origin", |
| 4306 | "Permissions-Policy", |
| 4307 | "Pragma", |
| 4308 | "Proxy-Authenticate", |
| 4309 | "Proxy-Authorization", |
| 4310 | "RTT", |
| 4311 | "Range", |
| 4312 | "Referer", |
| 4313 | "Referrer-Policy", |
| 4314 | "Refresh", |
| 4315 | "Retry-After", |
| 4316 | "Sec-WebSocket-Accept", |
| 4317 | "Sec-WebSocket-Extensions", |
| 4318 | "Sec-WebSocket-Key", |
| 4319 | "Sec-WebSocket-Protocol", |
| 4320 | "Sec-WebSocket-Version", |
| 4321 | "Server", |
| 4322 | "Server-Timing", |
| 4323 | "Service-Worker-Allowed", |
| 4324 | "Service-Worker-Navigation-Preload", |
| 4325 | "Set-Cookie", |
| 4326 | "SourceMap", |
| 4327 | "Strict-Transport-Security", |
| 4328 | "Supports-Loading-Mode", |
| 4329 | "TE", |
| 4330 | "Timing-Allow-Origin", |
| 4331 | "Trailer", |
| 4332 | "Transfer-Encoding", |
| 4333 | "Upgrade", |
| 4334 | "Upgrade-Insecure-Requests", |
| 4335 | "User-Agent", |
| 4336 | "Vary", |
| 4337 | "Via", |
| 4338 | "WWW-Authenticate", |
| 4339 | "X-Content-Type-Options", |
| 4340 | "X-DNS-Prefetch-Control", |
| 4341 | "X-Frame-Options", |
| 4342 | "X-Permitted-Cross-Domain-Policies", |
| 4343 | "X-Powered-By", |
| 4344 | "X-Requested-With", |
| 4345 | "X-XSS-Protection" |
| 4346 | ]; |
| 4347 | for (let i = 0; i < wellknownHeaderNames.length; ++i) { |
| 4348 | const key = wellknownHeaderNames[i]; |
| 4349 | const lowerCasedKey = key.toLowerCase(); |
| 4350 | headerNameLowerCasedRecord[key] = headerNameLowerCasedRecord[lowerCasedKey] = lowerCasedKey; |
| 4351 | } |
| 4352 | Object.setPrototypeOf(headerNameLowerCasedRecord, null); |
| 4353 | module2.exports = { |
| 4354 | wellknownHeaderNames, |
| 4355 | headerNameLowerCasedRecord |
| 4356 | }; |
| 4357 | } |
| 4358 | }); |
| 4359 | |
| 4360 | // node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/core/util.js |
| 4361 | var require_util = __commonJS({ |
| 4362 | "node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/core/util.js"(exports2, module2) { |
| 4363 | "use strict"; |
| 4364 | var assert = require("assert"); |
| 4365 | var { kDestroyed, kBodyUsed } = require_symbols(); |
| 4366 | var { IncomingMessage } = require("http"); |
| 4367 | var stream = require("stream"); |
| 4368 | var net = require("net"); |
| 4369 | var { InvalidArgumentError: InvalidArgumentError2 } = require_errors(); |
| 4370 | var { Blob: Blob2 } = require("buffer"); |
| 4371 | var nodeUtil = require("util"); |
| 4372 | var { stringify } = require("querystring"); |
| 4373 | var { headerNameLowerCasedRecord } = require_constants(); |
| 4374 | var [nodeMajor, nodeMinor] = process.versions.node.split(".").map((v) => Number(v)); |
| 4375 | function nop() { |
| 4376 | } |
| 4377 | function isStream(obj) { |
| 4378 | return obj && typeof obj === "object" && typeof obj.pipe === "function" && typeof obj.on === "function"; |
| 4379 | } |
| 4380 | function isBlobLike(object) { |
| 4381 | return Blob2 && object instanceof Blob2 || object && typeof object === "object" && (typeof object.stream === "function" || typeof object.arrayBuffer === "function") && /^(Blob|File)$/.test(object[Symbol.toStringTag]); |
| 4382 | } |
| 4383 | function buildURL(url, queryParams) { |
| 4384 | if (url.includes("?") || url.includes("#")) { |
| 4385 | throw new Error('Query params cannot be passed when url already contains "?" or "#".'); |
| 4386 | } |
| 4387 | const stringified = stringify(queryParams); |
| 4388 | if (stringified) { |
| 4389 | url += "?" + stringified; |
| 4390 | } |
| 4391 | return url; |
| 4392 | } |
| 4393 | function parseURL(url) { |
| 4394 | if (typeof url === "string") { |
| 4395 | url = new URL(url); |
| 4396 | if (!/^https?:/.test(url.origin || url.protocol)) { |
| 4397 | throw new InvalidArgumentError2("Invalid URL protocol: the URL must start with `http:` or `https:`."); |
| 4398 | } |
| 4399 | return url; |
| 4400 | } |
| 4401 | if (!url || typeof url !== "object") { |
| 4402 | throw new InvalidArgumentError2("Invalid URL: The URL argument must be a non-null object."); |
| 4403 | } |
| 4404 | if (!/^https?:/.test(url.origin || url.protocol)) { |
| 4405 | throw new InvalidArgumentError2("Invalid URL protocol: the URL must start with `http:` or `https:`."); |
| 4406 | } |
| 4407 | if (!(url instanceof URL)) { |
| 4408 | if (url.port != null && url.port !== "" && !Number.isFinite(parseInt(url.port))) { |
| 4409 | throw new InvalidArgumentError2("Invalid URL: port must be a valid integer or a string representation of an integer."); |
| 4410 | } |
| 4411 | if (url.path != null && typeof url.path !== "string") { |
| 4412 | throw new InvalidArgumentError2("Invalid URL path: the path must be a string or null/undefined."); |
| 4413 | } |
| 4414 | if (url.pathname != null && typeof url.pathname !== "string") { |
| 4415 | throw new InvalidArgumentError2("Invalid URL pathname: the pathname must be a string or null/undefined."); |
| 4416 | } |
| 4417 | if (url.hostname != null && typeof url.hostname !== "string") { |
| 4418 | throw new InvalidArgumentError2("Invalid URL hostname: the hostname must be a string or null/undefined."); |
| 4419 | } |
| 4420 | if (url.origin != null && typeof url.origin !== "string") { |
| 4421 | throw new InvalidArgumentError2("Invalid URL origin: the origin must be a string or null/undefined."); |
| 4422 | } |
| 4423 | const port = url.port != null ? url.port : url.protocol === "https:" ? 443 : 80; |
| 4424 | let origin = url.origin != null ? url.origin : `${url.protocol}//${url.hostname}:${port}`; |
| 4425 | let path5 = url.path != null ? url.path : `${url.pathname || ""}${url.search || ""}`; |
| 4426 | if (origin.endsWith("/")) { |
| 4427 | origin = origin.substring(0, origin.length - 1); |
| 4428 | } |
| 4429 | if (path5 && !path5.startsWith("/")) { |
| 4430 | path5 = `/${path5}`; |
| 4431 | } |
| 4432 | url = new URL(origin + path5); |
| 4433 | } |
| 4434 | return url; |
| 4435 | } |
| 4436 | function parseOrigin(url) { |
| 4437 | url = parseURL(url); |
| 4438 | if (url.pathname !== "/" || url.search || url.hash) { |
| 4439 | throw new InvalidArgumentError2("invalid url"); |
| 4440 | } |
| 4441 | return url; |
| 4442 | } |
| 4443 | function getHostname(host) { |
| 4444 | if (host[0] === "[") { |
| 4445 | const idx2 = host.indexOf("]"); |
| 4446 | assert(idx2 !== -1); |
| 4447 | return host.substring(1, idx2); |
| 4448 | } |
| 4449 | const idx = host.indexOf(":"); |
| 4450 | if (idx === -1) return host; |
| 4451 | return host.substring(0, idx); |
| 4452 | } |
| 4453 | function getServerName(host) { |
| 4454 | if (!host) { |
| 4455 | return null; |
| 4456 | } |
| 4457 | assert.strictEqual(typeof host, "string"); |
| 4458 | const servername = getHostname(host); |
| 4459 | if (net.isIP(servername)) { |
| 4460 | return ""; |
| 4461 | } |
| 4462 | return servername; |
| 4463 | } |
| 4464 | function deepClone(obj) { |
| 4465 | return JSON.parse(JSON.stringify(obj)); |
| 4466 | } |
| 4467 | function isAsyncIterable(obj) { |
| 4468 | return !!(obj != null && typeof obj[Symbol.asyncIterator] === "function"); |
| 4469 | } |
| 4470 | function isIterable(obj) { |
| 4471 | return !!(obj != null && (typeof obj[Symbol.iterator] === "function" || typeof obj[Symbol.asyncIterator] === "function")); |
| 4472 | } |
| 4473 | function bodyLength(body) { |
| 4474 | if (body == null) { |
| 4475 | return 0; |
| 4476 | } else if (isStream(body)) { |
| 4477 | const state = body._readableState; |
| 4478 | return state && state.objectMode === false && state.ended === true && Number.isFinite(state.length) ? state.length : null; |
| 4479 | } else if (isBlobLike(body)) { |
| 4480 | return body.size != null ? body.size : null; |
| 4481 | } else if (isBuffer(body)) { |
| 4482 | return body.byteLength; |
| 4483 | } |
| 4484 | return null; |
| 4485 | } |
| 4486 | function isDestroyed(stream2) { |
| 4487 | return !stream2 || !!(stream2.destroyed || stream2[kDestroyed]); |
| 4488 | } |
| 4489 | function isReadableAborted(stream2) { |
| 4490 | const state = stream2 && stream2._readableState; |
| 4491 | return isDestroyed(stream2) && state && !state.endEmitted; |
| 4492 | } |
| 4493 | function destroy(stream2, err) { |
| 4494 | if (stream2 == null || !isStream(stream2) || isDestroyed(stream2)) { |
| 4495 | return; |
| 4496 | } |
| 4497 | if (typeof stream2.destroy === "function") { |
| 4498 | if (Object.getPrototypeOf(stream2).constructor === IncomingMessage) { |
| 4499 | stream2.socket = null; |
| 4500 | } |
| 4501 | stream2.destroy(err); |
| 4502 | } else if (err) { |
| 4503 | process.nextTick((stream3, err2) => { |
| 4504 | stream3.emit("error", err2); |
| 4505 | }, stream2, err); |
| 4506 | } |
| 4507 | if (stream2.destroyed !== true) { |
| 4508 | stream2[kDestroyed] = true; |
| 4509 | } |
| 4510 | } |
| 4511 | var KEEPALIVE_TIMEOUT_EXPR = /timeout=(\d+)/; |
| 4512 | function parseKeepAliveTimeout(val) { |
| 4513 | const m = val.toString().match(KEEPALIVE_TIMEOUT_EXPR); |
| 4514 | return m ? parseInt(m[1], 10) * 1e3 : null; |
| 4515 | } |
| 4516 | function headerNameToString(value) { |
| 4517 | return headerNameLowerCasedRecord[value] || value.toLowerCase(); |
| 4518 | } |
| 4519 | function parseHeaders(headers, obj = {}) { |
| 4520 | if (!Array.isArray(headers)) return headers; |
| 4521 | for (let i = 0; i < headers.length; i += 2) { |
| 4522 | const key = headers[i].toString().toLowerCase(); |
| 4523 | let val = obj[key]; |
| 4524 | if (!val) { |
| 4525 | if (Array.isArray(headers[i + 1])) { |
| 4526 | obj[key] = headers[i + 1].map((x) => x.toString("utf8")); |
| 4527 | } else { |
| 4528 | obj[key] = headers[i + 1].toString("utf8"); |
| 4529 | } |
| 4530 | } else { |
| 4531 | if (!Array.isArray(val)) { |
| 4532 | val = [val]; |
| 4533 | obj[key] = val; |
| 4534 | } |
| 4535 | val.push(headers[i + 1].toString("utf8")); |
| 4536 | } |
| 4537 | } |
| 4538 | if ("content-length" in obj && "content-disposition" in obj) { |
| 4539 | obj["content-disposition"] = Buffer.from(obj["content-disposition"]).toString("latin1"); |
| 4540 | } |
| 4541 | return obj; |
| 4542 | } |
| 4543 | function parseRawHeaders(headers) { |
| 4544 | const ret = []; |
| 4545 | let hasContentLength = false; |
| 4546 | let contentDispositionIdx = -1; |
| 4547 | for (let n = 0; n < headers.length; n += 2) { |
| 4548 | const key = headers[n + 0].toString(); |
| 4549 | const val = headers[n + 1].toString("utf8"); |
| 4550 | if (key.length === 14 && (key === "content-length" || key.toLowerCase() === "content-length")) { |
| 4551 | ret.push(key, val); |
| 4552 | hasContentLength = true; |
| 4553 | } else if (key.length === 19 && (key === "content-disposition" || key.toLowerCase() === "content-disposition")) { |
| 4554 | contentDispositionIdx = ret.push(key, val) - 1; |
| 4555 | } else { |
| 4556 | ret.push(key, val); |
| 4557 | } |
| 4558 | } |
| 4559 | if (hasContentLength && contentDispositionIdx !== -1) { |
| 4560 | ret[contentDispositionIdx] = Buffer.from(ret[contentDispositionIdx]).toString("latin1"); |
| 4561 | } |
| 4562 | return ret; |
| 4563 | } |
| 4564 | function isBuffer(buffer) { |
| 4565 | return buffer instanceof Uint8Array || Buffer.isBuffer(buffer); |
| 4566 | } |
| 4567 | function validateHandler(handler2, method, upgrade) { |
| 4568 | if (!handler2 || typeof handler2 !== "object") { |
| 4569 | throw new InvalidArgumentError2("handler must be an object"); |
| 4570 | } |
| 4571 | if (typeof handler2.onConnect !== "function") { |
| 4572 | throw new InvalidArgumentError2("invalid onConnect method"); |
| 4573 | } |
| 4574 | if (typeof handler2.onError !== "function") { |
| 4575 | throw new InvalidArgumentError2("invalid onError method"); |
| 4576 | } |
| 4577 | if (typeof handler2.onBodySent !== "function" && handler2.onBodySent !== void 0) { |
| 4578 | throw new InvalidArgumentError2("invalid onBodySent method"); |
| 4579 | } |
| 4580 | if (upgrade || method === "CONNECT") { |
| 4581 | if (typeof handler2.onUpgrade !== "function") { |
| 4582 | throw new InvalidArgumentError2("invalid onUpgrade method"); |
| 4583 | } |
| 4584 | } else { |
| 4585 | if (typeof handler2.onHeaders !== "function") { |
| 4586 | throw new InvalidArgumentError2("invalid onHeaders method"); |
| 4587 | } |
| 4588 | if (typeof handler2.onData !== "function") { |
| 4589 | throw new InvalidArgumentError2("invalid onData method"); |
| 4590 | } |
| 4591 | if (typeof handler2.onComplete !== "function") { |
| 4592 | throw new InvalidArgumentError2("invalid onComplete method"); |
| 4593 | } |
| 4594 | } |
| 4595 | } |
| 4596 | function isDisturbed(body) { |
| 4597 | return !!(body && (stream.isDisturbed ? stream.isDisturbed(body) || body[kBodyUsed] : body[kBodyUsed] || body.readableDidRead || body._readableState && body._readableState.dataEmitted || isReadableAborted(body))); |
| 4598 | } |
| 4599 | function isErrored(body) { |
| 4600 | return !!(body && (stream.isErrored ? stream.isErrored(body) : /state: 'errored'/.test( |
| 4601 | nodeUtil.inspect(body) |
| 4602 | ))); |
| 4603 | } |
| 4604 | function isReadable(body) { |
| 4605 | return !!(body && (stream.isReadable ? stream.isReadable(body) : /state: 'readable'/.test( |
| 4606 | nodeUtil.inspect(body) |
| 4607 | ))); |
| 4608 | } |
| 4609 | function getSocketInfo(socket) { |
| 4610 | return { |
| 4611 | localAddress: socket.localAddress, |
| 4612 | localPort: socket.localPort, |
| 4613 | remoteAddress: socket.remoteAddress, |
| 4614 | remotePort: socket.remotePort, |
| 4615 | remoteFamily: socket.remoteFamily, |
| 4616 | timeout: socket.timeout, |
| 4617 | bytesWritten: socket.bytesWritten, |
| 4618 | bytesRead: socket.bytesRead |
| 4619 | }; |
| 4620 | } |
| 4621 | async function* convertIterableToBuffer(iterable) { |
| 4622 | for await (const chunk of iterable) { |
| 4623 | yield Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk); |
| 4624 | } |
| 4625 | } |
| 4626 | var ReadableStream; |
| 4627 | function ReadableStreamFrom(iterable) { |
| 4628 | if (!ReadableStream) { |
| 4629 | ReadableStream = require("stream/web").ReadableStream; |
| 4630 | } |
| 4631 | if (ReadableStream.from) { |
| 4632 | return ReadableStream.from(convertIterableToBuffer(iterable)); |
| 4633 | } |
| 4634 | let iterator2; |
| 4635 | return new ReadableStream( |
| 4636 | { |
| 4637 | async start() { |
| 4638 | iterator2 = iterable[Symbol.asyncIterator](); |
| 4639 | }, |
| 4640 | async pull(controller) { |
| 4641 | const { done, value } = await iterator2.next(); |
| 4642 | if (done) { |
| 4643 | queueMicrotask(() => { |
| 4644 | controller.close(); |
| 4645 | }); |
| 4646 | } else { |
| 4647 | const buf = Buffer.isBuffer(value) ? value : Buffer.from(value); |
| 4648 | controller.enqueue(new Uint8Array(buf)); |
| 4649 | } |
| 4650 | return controller.desiredSize > 0; |
| 4651 | }, |
| 4652 | async cancel(reason) { |
| 4653 | await iterator2.return(); |
| 4654 | } |
| 4655 | }, |
| 4656 | 0 |
| 4657 | ); |
| 4658 | } |
| 4659 | function isFormDataLike(object) { |
| 4660 | return object && typeof object === "object" && typeof object.append === "function" && typeof object.delete === "function" && typeof object.get === "function" && typeof object.getAll === "function" && typeof object.has === "function" && typeof object.set === "function" && object[Symbol.toStringTag] === "FormData"; |
| 4661 | } |
| 4662 | function throwIfAborted(signal) { |
| 4663 | if (!signal) { |
| 4664 | return; |
| 4665 | } |
| 4666 | if (typeof signal.throwIfAborted === "function") { |
| 4667 | signal.throwIfAborted(); |
| 4668 | } else { |
| 4669 | if (signal.aborted) { |
| 4670 | const err = new Error("The operation was aborted"); |
| 4671 | err.name = "AbortError"; |
| 4672 | throw err; |
| 4673 | } |
| 4674 | } |
| 4675 | } |
| 4676 | function addAbortListener(signal, listener) { |
| 4677 | if ("addEventListener" in signal) { |
| 4678 | signal.addEventListener("abort", listener, { once: true }); |
| 4679 | return () => signal.removeEventListener("abort", listener); |
| 4680 | } |
| 4681 | signal.addListener("abort", listener); |
| 4682 | return () => signal.removeListener("abort", listener); |
| 4683 | } |
| 4684 | var hasToWellFormed = !!String.prototype.toWellFormed; |
| 4685 | function toUSVString(val) { |
| 4686 | if (hasToWellFormed) { |
| 4687 | return `${val}`.toWellFormed(); |
| 4688 | } else if (nodeUtil.toUSVString) { |
| 4689 | return nodeUtil.toUSVString(val); |
| 4690 | } |
| 4691 | return `${val}`; |
| 4692 | } |
| 4693 | function parseRangeHeader(range) { |
| 4694 | if (range == null || range === "") return { start: 0, end: null, size: null }; |
| 4695 | const m = range ? range.match(/^bytes (\d+)-(\d+)\/(\d+)?$/) : null; |
| 4696 | return m ? { |
| 4697 | start: parseInt(m[1]), |
| 4698 | end: m[2] ? parseInt(m[2]) : null, |
| 4699 | size: m[3] ? parseInt(m[3]) : null |
| 4700 | } : null; |
| 4701 | } |
| 4702 | var kEnumerableProperty = /* @__PURE__ */ Object.create(null); |
| 4703 | kEnumerableProperty.enumerable = true; |
| 4704 | module2.exports = { |
| 4705 | kEnumerableProperty, |
| 4706 | nop, |
| 4707 | isDisturbed, |
| 4708 | isErrored, |
| 4709 | isReadable, |
| 4710 | toUSVString, |
| 4711 | isReadableAborted, |
| 4712 | isBlobLike, |
| 4713 | parseOrigin, |
| 4714 | parseURL, |
| 4715 | getServerName, |
| 4716 | isStream, |
| 4717 | isIterable, |
| 4718 | isAsyncIterable, |
| 4719 | isDestroyed, |
| 4720 | headerNameToString, |
| 4721 | parseRawHeaders, |
| 4722 | parseHeaders, |
| 4723 | parseKeepAliveTimeout, |
| 4724 | destroy, |
| 4725 | bodyLength, |
| 4726 | deepClone, |
| 4727 | ReadableStreamFrom, |
| 4728 | isBuffer, |
| 4729 | validateHandler, |
| 4730 | getSocketInfo, |
| 4731 | isFormDataLike, |
| 4732 | buildURL, |
| 4733 | throwIfAborted, |
| 4734 | addAbortListener, |
| 4735 | parseRangeHeader, |
| 4736 | nodeMajor, |
| 4737 | nodeMinor, |
| 4738 | nodeHasAutoSelectFamily: nodeMajor > 18 || nodeMajor === 18 && nodeMinor >= 13, |
| 4739 | safeHTTPMethods: ["GET", "HEAD", "OPTIONS", "TRACE"] |
| 4740 | }; |
| 4741 | } |
| 4742 | }); |
| 4743 | |
| 4744 | // node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/timers.js |
| 4745 | var require_timers = __commonJS({ |
| 4746 | "node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/timers.js"(exports2, module2) { |
| 4747 | "use strict"; |
| 4748 | var fastNow = Date.now(); |
| 4749 | var fastNowTimeout; |
| 4750 | var fastTimers = []; |
| 4751 | function onTimeout() { |
| 4752 | fastNow = Date.now(); |
| 4753 | let len = fastTimers.length; |
| 4754 | let idx = 0; |
| 4755 | while (idx < len) { |
| 4756 | const timer = fastTimers[idx]; |
| 4757 | if (timer.state === 0) { |
| 4758 | timer.state = fastNow + timer.delay; |
| 4759 | } else if (timer.state > 0 && fastNow >= timer.state) { |
| 4760 | timer.state = -1; |
| 4761 | timer.callback(timer.opaque); |
| 4762 | } |
| 4763 | if (timer.state === -1) { |
| 4764 | timer.state = -2; |
| 4765 | if (idx !== len - 1) { |
| 4766 | fastTimers[idx] = fastTimers.pop(); |
| 4767 | } else { |
| 4768 | fastTimers.pop(); |
| 4769 | } |
| 4770 | len -= 1; |
| 4771 | } else { |
| 4772 | idx += 1; |
| 4773 | } |
| 4774 | } |
| 4775 | if (fastTimers.length > 0) { |
| 4776 | refreshTimeout(); |
| 4777 | } |
| 4778 | } |
| 4779 | function refreshTimeout() { |
| 4780 | if (fastNowTimeout && fastNowTimeout.refresh) { |
| 4781 | fastNowTimeout.refresh(); |
| 4782 | } else { |
| 4783 | clearTimeout(fastNowTimeout); |
| 4784 | fastNowTimeout = setTimeout(onTimeout, 1e3); |
| 4785 | if (fastNowTimeout.unref) { |
| 4786 | fastNowTimeout.unref(); |
| 4787 | } |
| 4788 | } |
| 4789 | } |
| 4790 | var Timeout = class { |
| 4791 | constructor(callback, delay, opaque) { |
| 4792 | this.callback = callback; |
| 4793 | this.delay = delay; |
| 4794 | this.opaque = opaque; |
| 4795 | this.state = -2; |
| 4796 | this.refresh(); |
| 4797 | } |
| 4798 | refresh() { |
| 4799 | if (this.state === -2) { |
| 4800 | fastTimers.push(this); |
| 4801 | if (!fastNowTimeout || fastTimers.length === 1) { |
| 4802 | refreshTimeout(); |
| 4803 | } |
| 4804 | } |
| 4805 | this.state = 0; |
| 4806 | } |
| 4807 | clear() { |
| 4808 | this.state = -1; |
| 4809 | } |
| 4810 | }; |
| 4811 | module2.exports = { |
| 4812 | setTimeout(callback, delay, opaque) { |
| 4813 | return delay < 1e3 ? setTimeout(callback, delay, opaque) : new Timeout(callback, delay, opaque); |
| 4814 | }, |
| 4815 | clearTimeout(timeout) { |
| 4816 | if (timeout instanceof Timeout) { |
| 4817 | timeout.clear(); |
| 4818 | } else { |
| 4819 | clearTimeout(timeout); |
| 4820 | } |
| 4821 | } |
| 4822 | }; |
| 4823 | } |
| 4824 | }); |
| 4825 | |
| 4826 | // node_modules/.pnpm/@fastify+busboy@2.1.1/node_modules/@fastify/busboy/deps/streamsearch/sbmh.js |
| 4827 | var require_sbmh = __commonJS({ |
| 4828 | "node_modules/.pnpm/@fastify+busboy@2.1.1/node_modules/@fastify/busboy/deps/streamsearch/sbmh.js"(exports2, module2) { |
| 4829 | "use strict"; |
| 4830 | var EventEmitter = require("node:events").EventEmitter; |
| 4831 | var inherits = require("node:util").inherits; |
| 4832 | function SBMH(needle) { |
| 4833 | if (typeof needle === "string") { |
| 4834 | needle = Buffer.from(needle); |
| 4835 | } |
| 4836 | if (!Buffer.isBuffer(needle)) { |
| 4837 | throw new TypeError("The needle has to be a String or a Buffer."); |
| 4838 | } |
| 4839 | const needleLength = needle.length; |
| 4840 | if (needleLength === 0) { |
| 4841 | throw new Error("The needle cannot be an empty String/Buffer."); |
| 4842 | } |
| 4843 | if (needleLength > 256) { |
| 4844 | throw new Error("The needle cannot have a length bigger than 256."); |
| 4845 | } |
| 4846 | this.maxMatches = Infinity; |
| 4847 | this.matches = 0; |
| 4848 | this._occ = new Array(256).fill(needleLength); |
| 4849 | this._lookbehind_size = 0; |
| 4850 | this._needle = needle; |
| 4851 | this._bufpos = 0; |
| 4852 | this._lookbehind = Buffer.alloc(needleLength); |
| 4853 | for (var i = 0; i < needleLength - 1; ++i) { |
| 4854 | this._occ[needle[i]] = needleLength - 1 - i; |
| 4855 | } |
| 4856 | } |
| 4857 | inherits(SBMH, EventEmitter); |
| 4858 | SBMH.prototype.reset = function() { |
| 4859 | this._lookbehind_size = 0; |
| 4860 | this.matches = 0; |
| 4861 | this._bufpos = 0; |
| 4862 | }; |
| 4863 | SBMH.prototype.push = function(chunk, pos) { |
| 4864 | if (!Buffer.isBuffer(chunk)) { |
| 4865 | chunk = Buffer.from(chunk, "binary"); |
| 4866 | } |
| 4867 | const chlen = chunk.length; |
| 4868 | this._bufpos = pos || 0; |
| 4869 | let r; |
| 4870 | while (r !== chlen && this.matches < this.maxMatches) { |
| 4871 | r = this._sbmh_feed(chunk); |
| 4872 | } |
| 4873 | return r; |
| 4874 | }; |
| 4875 | SBMH.prototype._sbmh_feed = function(data) { |
| 4876 | const len = data.length; |
| 4877 | const needle = this._needle; |
| 4878 | const needleLength = needle.length; |
| 4879 | const lastNeedleChar = needle[needleLength - 1]; |
| 4880 | let pos = -this._lookbehind_size; |
| 4881 | let ch; |
| 4882 | if (pos < 0) { |
| 4883 | while (pos < 0 && pos <= len - needleLength) { |
| 4884 | ch = this._sbmh_lookup_char(data, pos + needleLength - 1); |
| 4885 | if (ch === lastNeedleChar && this._sbmh_memcmp(data, pos, needleLength - 1)) { |
| 4886 | this._lookbehind_size = 0; |
| 4887 | ++this.matches; |
| 4888 | this.emit("info", true); |
| 4889 | return this._bufpos = pos + needleLength; |
| 4890 | } |
| 4891 | pos += this._occ[ch]; |
| 4892 | } |
| 4893 | if (pos < 0) { |
| 4894 | while (pos < 0 && !this._sbmh_memcmp(data, pos, len - pos)) { |
| 4895 | ++pos; |
| 4896 | } |
| 4897 | } |
| 4898 | if (pos >= 0) { |
| 4899 | this.emit("info", false, this._lookbehind, 0, this._lookbehind_size); |
| 4900 | this._lookbehind_size = 0; |
| 4901 | } else { |
| 4902 | const bytesToCutOff = this._lookbehind_size + pos; |
| 4903 | if (bytesToCutOff > 0) { |
| 4904 | this.emit("info", false, this._lookbehind, 0, bytesToCutOff); |
| 4905 | } |
| 4906 | this._lookbehind.copy( |
| 4907 | this._lookbehind, |
| 4908 | 0, |
| 4909 | bytesToCutOff, |
| 4910 | this._lookbehind_size - bytesToCutOff |
| 4911 | ); |
| 4912 | this._lookbehind_size -= bytesToCutOff; |
| 4913 | data.copy(this._lookbehind, this._lookbehind_size); |
| 4914 | this._lookbehind_size += len; |
| 4915 | this._bufpos = len; |
| 4916 | return len; |
| 4917 | } |
| 4918 | } |
| 4919 | pos += (pos >= 0) * this._bufpos; |
| 4920 | if (data.indexOf(needle, pos) !== -1) { |
| 4921 | pos = data.indexOf(needle, pos); |
| 4922 | ++this.matches; |
| 4923 | if (pos > 0) { |
| 4924 | this.emit("info", true, data, this._bufpos, pos); |
| 4925 | } else { |
| 4926 | this.emit("info", true); |
| 4927 | } |
| 4928 | return this._bufpos = pos + needleLength; |
| 4929 | } else { |
| 4930 | pos = len - needleLength; |
| 4931 | } |
| 4932 | while (pos < len && (data[pos] !== needle[0] || Buffer.compare( |
| 4933 | data.subarray(pos, pos + len - pos), |
| 4934 | needle.subarray(0, len - pos) |
| 4935 | ) !== 0)) { |
| 4936 | ++pos; |
| 4937 | } |
| 4938 | if (pos < len) { |
| 4939 | data.copy(this._lookbehind, 0, pos, pos + (len - pos)); |
| 4940 | this._lookbehind_size = len - pos; |
| 4941 | } |
| 4942 | if (pos > 0) { |
| 4943 | this.emit("info", false, data, this._bufpos, pos < len ? pos : len); |
| 4944 | } |
| 4945 | this._bufpos = len; |
| 4946 | return len; |
| 4947 | }; |
| 4948 | SBMH.prototype._sbmh_lookup_char = function(data, pos) { |
| 4949 | return pos < 0 ? this._lookbehind[this._lookbehind_size + pos] : data[pos]; |
| 4950 | }; |
| 4951 | SBMH.prototype._sbmh_memcmp = function(data, pos, len) { |
| 4952 | for (var i = 0; i < len; ++i) { |
| 4953 | if (this._sbmh_lookup_char(data, pos + i) !== this._needle[i]) { |
| 4954 | return false; |
| 4955 | } |
| 4956 | } |
| 4957 | return true; |
| 4958 | }; |
| 4959 | module2.exports = SBMH; |
| 4960 | } |
| 4961 | }); |
| 4962 | |
| 4963 | // node_modules/.pnpm/@fastify+busboy@2.1.1/node_modules/@fastify/busboy/deps/dicer/lib/PartStream.js |
| 4964 | var require_PartStream = __commonJS({ |
| 4965 | "node_modules/.pnpm/@fastify+busboy@2.1.1/node_modules/@fastify/busboy/deps/dicer/lib/PartStream.js"(exports2, module2) { |
| 4966 | "use strict"; |
| 4967 | var inherits = require("node:util").inherits; |
| 4968 | var ReadableStream = require("node:stream").Readable; |
| 4969 | function PartStream(opts) { |
| 4970 | ReadableStream.call(this, opts); |
| 4971 | } |
| 4972 | inherits(PartStream, ReadableStream); |
| 4973 | PartStream.prototype._read = function(n) { |
| 4974 | }; |
| 4975 | module2.exports = PartStream; |
| 4976 | } |
| 4977 | }); |
| 4978 | |
| 4979 | // node_modules/.pnpm/@fastify+busboy@2.1.1/node_modules/@fastify/busboy/lib/utils/getLimit.js |
| 4980 | var require_getLimit = __commonJS({ |
| 4981 | "node_modules/.pnpm/@fastify+busboy@2.1.1/node_modules/@fastify/busboy/lib/utils/getLimit.js"(exports2, module2) { |
| 4982 | "use strict"; |
| 4983 | module2.exports = function getLimit(limits, name, defaultLimit) { |
| 4984 | if (!limits || limits[name] === void 0 || limits[name] === null) { |
| 4985 | return defaultLimit; |
| 4986 | } |
| 4987 | if (typeof limits[name] !== "number" || isNaN(limits[name])) { |
| 4988 | throw new TypeError("Limit " + name + " is not a valid number"); |
| 4989 | } |
| 4990 | return limits[name]; |
| 4991 | }; |
| 4992 | } |
| 4993 | }); |
| 4994 | |
| 4995 | // node_modules/.pnpm/@fastify+busboy@2.1.1/node_modules/@fastify/busboy/deps/dicer/lib/HeaderParser.js |
| 4996 | var require_HeaderParser = __commonJS({ |
| 4997 | "node_modules/.pnpm/@fastify+busboy@2.1.1/node_modules/@fastify/busboy/deps/dicer/lib/HeaderParser.js"(exports2, module2) { |
| 4998 | "use strict"; |
| 4999 | var EventEmitter = require("node:events").EventEmitter; |
| 5000 | var inherits = require("node:util").inherits; |
| 5001 | var getLimit = require_getLimit(); |
| 5002 | var StreamSearch = require_sbmh(); |
| 5003 | var B_DCRLF = Buffer.from("\r\n\r\n"); |
| 5004 | var RE_CRLF = /\r\n/g; |
| 5005 | var RE_HDR = /^([^:]+):[ \t]?([\x00-\xFF]+)?$/; |
| 5006 | function HeaderParser(cfg) { |
| 5007 | EventEmitter.call(this); |
| 5008 | cfg = cfg || {}; |
| 5009 | const self = this; |
| 5010 | this.nread = 0; |
| 5011 | this.maxed = false; |
| 5012 | this.npairs = 0; |
| 5013 | this.maxHeaderPairs = getLimit(cfg, "maxHeaderPairs", 2e3); |
| 5014 | this.maxHeaderSize = getLimit(cfg, "maxHeaderSize", 80 * 1024); |
| 5015 | this.buffer = ""; |
| 5016 | this.header = {}; |
| 5017 | this.finished = false; |
| 5018 | this.ss = new StreamSearch(B_DCRLF); |
| 5019 | this.ss.on("info", function(isMatch, data, start, end) { |
| 5020 | if (data && !self.maxed) { |
| 5021 | if (self.nread + end - start >= self.maxHeaderSize) { |
| 5022 | end = self.maxHeaderSize - self.nread + start; |
| 5023 | self.nread = self.maxHeaderSize; |
| 5024 | self.maxed = true; |
| 5025 | } else { |
| 5026 | self.nread += end - start; |
| 5027 | } |
| 5028 | self.buffer += data.toString("binary", start, end); |
| 5029 | } |
| 5030 | if (isMatch) { |
| 5031 | self._finish(); |
| 5032 | } |
| 5033 | }); |
| 5034 | } |
| 5035 | inherits(HeaderParser, EventEmitter); |
| 5036 | HeaderParser.prototype.push = function(data) { |
| 5037 | const r = this.ss.push(data); |
| 5038 | if (this.finished) { |
| 5039 | return r; |
| 5040 | } |
| 5041 | }; |
| 5042 | HeaderParser.prototype.reset = function() { |
| 5043 | this.finished = false; |
| 5044 | this.buffer = ""; |
| 5045 | this.header = {}; |
| 5046 | this.ss.reset(); |
| 5047 | }; |
| 5048 | HeaderParser.prototype._finish = function() { |
| 5049 | if (this.buffer) { |
| 5050 | this._parseHeader(); |
| 5051 | } |
| 5052 | this.ss.matches = this.ss.maxMatches; |
| 5053 | const header = this.header; |
| 5054 | this.header = {}; |
| 5055 | this.buffer = ""; |
| 5056 | this.finished = true; |
| 5057 | this.nread = this.npairs = 0; |
| 5058 | this.maxed = false; |
| 5059 | this.emit("header", header); |
| 5060 | }; |
| 5061 | HeaderParser.prototype._parseHeader = function() { |
| 5062 | if (this.npairs === this.maxHeaderPairs) { |
| 5063 | return; |
| 5064 | } |
| 5065 | const lines = this.buffer.split(RE_CRLF); |
| 5066 | const len = lines.length; |
| 5067 | let m, h; |
| 5068 | for (var i = 0; i < len; ++i) { |
| 5069 | if (lines[i].length === 0) { |
| 5070 | continue; |
| 5071 | } |
| 5072 | if (lines[i][0] === " " || lines[i][0] === " ") { |
| 5073 | if (h) { |
| 5074 | this.header[h][this.header[h].length - 1] += lines[i]; |
| 5075 | continue; |
| 5076 | } |
| 5077 | } |
| 5078 | const posColon = lines[i].indexOf(":"); |
| 5079 | if (posColon === -1 || posColon === 0) { |
| 5080 | return; |
| 5081 | } |
| 5082 | m = RE_HDR.exec(lines[i]); |
| 5083 | h = m[1].toLowerCase(); |
| 5084 | this.header[h] = this.header[h] || []; |
| 5085 | this.header[h].push(m[2] || ""); |
| 5086 | if (++this.npairs === this.maxHeaderPairs) { |
| 5087 | break; |
| 5088 | } |
| 5089 | } |
| 5090 | }; |
| 5091 | module2.exports = HeaderParser; |
| 5092 | } |
| 5093 | }); |
| 5094 | |
| 5095 | // node_modules/.pnpm/@fastify+busboy@2.1.1/node_modules/@fastify/busboy/deps/dicer/lib/Dicer.js |
| 5096 | var require_Dicer = __commonJS({ |
| 5097 | "node_modules/.pnpm/@fastify+busboy@2.1.1/node_modules/@fastify/busboy/deps/dicer/lib/Dicer.js"(exports2, module2) { |
| 5098 | "use strict"; |
| 5099 | var WritableStream = require("node:stream").Writable; |
| 5100 | var inherits = require("node:util").inherits; |
| 5101 | var StreamSearch = require_sbmh(); |
| 5102 | var PartStream = require_PartStream(); |
| 5103 | var HeaderParser = require_HeaderParser(); |
| 5104 | var DASH = 45; |
| 5105 | var B_ONEDASH = Buffer.from("-"); |
| 5106 | var B_CRLF = Buffer.from("\r\n"); |
| 5107 | var EMPTY_FN = function() { |
| 5108 | }; |
| 5109 | function Dicer(cfg) { |
| 5110 | if (!(this instanceof Dicer)) { |
| 5111 | return new Dicer(cfg); |
| 5112 | } |
| 5113 | WritableStream.call(this, cfg); |
| 5114 | if (!cfg || !cfg.headerFirst && typeof cfg.boundary !== "string") { |
| 5115 | throw new TypeError("Boundary required"); |
| 5116 | } |
| 5117 | if (typeof cfg.boundary === "string") { |
| 5118 | this.setBoundary(cfg.boundary); |
| 5119 | } else { |
| 5120 | this._bparser = void 0; |
| 5121 | } |
| 5122 | this._headerFirst = cfg.headerFirst; |
| 5123 | this._dashes = 0; |
| 5124 | this._parts = 0; |
| 5125 | this._finished = false; |
| 5126 | this._realFinish = false; |
| 5127 | this._isPreamble = true; |
| 5128 | this._justMatched = false; |
| 5129 | this._firstWrite = true; |
| 5130 | this._inHeader = true; |
| 5131 | this._part = void 0; |
| 5132 | this._cb = void 0; |
| 5133 | this._ignoreData = false; |
| 5134 | this._partOpts = { highWaterMark: cfg.partHwm }; |
| 5135 | this._pause = false; |
| 5136 | const self = this; |
| 5137 | this._hparser = new HeaderParser(cfg); |
| 5138 | this._hparser.on("header", function(header) { |
| 5139 | self._inHeader = false; |
| 5140 | self._part.emit("header", header); |
| 5141 | }); |
| 5142 | } |
| 5143 | inherits(Dicer, WritableStream); |
| 5144 | Dicer.prototype.emit = function(ev) { |
| 5145 | if (ev === "finish" && !this._realFinish) { |
| 5146 | if (!this._finished) { |
| 5147 | const self = this; |
| 5148 | process.nextTick(function() { |
| 5149 | self.emit("error", new Error("Unexpected end of multipart data")); |
| 5150 | if (self._part && !self._ignoreData) { |
| 5151 | const type = self._isPreamble ? "Preamble" : "Part"; |
| 5152 | self._part.emit("error", new Error(type + " terminated early due to unexpected end of multipart data")); |
| 5153 | self._part.push(null); |
| 5154 | process.nextTick(function() { |
| 5155 | self._realFinish = true; |
| 5156 | self.emit("finish"); |
| 5157 | self._realFinish = false; |
| 5158 | }); |
| 5159 | return; |
| 5160 | } |
| 5161 | self._realFinish = true; |
| 5162 | self.emit("finish"); |
| 5163 | self._realFinish = false; |
| 5164 | }); |
| 5165 | } |
| 5166 | } else { |
| 5167 | WritableStream.prototype.emit.apply(this, arguments); |
| 5168 | } |
| 5169 | }; |
| 5170 | Dicer.prototype._write = function(data, encoding, cb) { |
| 5171 | if (!this._hparser && !this._bparser) { |
| 5172 | return cb(); |
| 5173 | } |
| 5174 | if (this._headerFirst && this._isPreamble) { |
| 5175 | if (!this._part) { |
| 5176 | this._part = new PartStream(this._partOpts); |
| 5177 | if (this.listenerCount("preamble") !== 0) { |
| 5178 | this.emit("preamble", this._part); |
| 5179 | } else { |
| 5180 | this._ignore(); |
| 5181 | } |
| 5182 | } |
| 5183 | const r = this._hparser.push(data); |
| 5184 | if (!this._inHeader && r !== void 0 && r < data.length) { |
| 5185 | data = data.slice(r); |
| 5186 | } else { |
| 5187 | return cb(); |
| 5188 | } |
| 5189 | } |
| 5190 | if (this._firstWrite) { |
| 5191 | this._bparser.push(B_CRLF); |
| 5192 | this._firstWrite = false; |
| 5193 | } |
| 5194 | this._bparser.push(data); |
| 5195 | if (this._pause) { |
| 5196 | this._cb = cb; |
| 5197 | } else { |
| 5198 | cb(); |
| 5199 | } |
| 5200 | }; |
| 5201 | Dicer.prototype.reset = function() { |
| 5202 | this._part = void 0; |
| 5203 | this._bparser = void 0; |
| 5204 | this._hparser = void 0; |
| 5205 | }; |
| 5206 | Dicer.prototype.setBoundary = function(boundary) { |
| 5207 | const self = this; |
| 5208 | this._bparser = new StreamSearch("\r\n--" + boundary); |
| 5209 | this._bparser.on("info", function(isMatch, data, start, end) { |
| 5210 | self._oninfo(isMatch, data, start, end); |
| 5211 | }); |
| 5212 | }; |
| 5213 | Dicer.prototype._ignore = function() { |
| 5214 | if (this._part && !this._ignoreData) { |
| 5215 | this._ignoreData = true; |
| 5216 | this._part.on("error", EMPTY_FN); |
| 5217 | this._part.resume(); |
| 5218 | } |
| 5219 | }; |
| 5220 | Dicer.prototype._oninfo = function(isMatch, data, start, end) { |
| 5221 | let buf; |
| 5222 | const self = this; |
| 5223 | let i = 0; |
| 5224 | let r; |
| 5225 | let shouldWriteMore = true; |
| 5226 | if (!this._part && this._justMatched && data) { |
| 5227 | while (this._dashes < 2 && start + i < end) { |
| 5228 | if (data[start + i] === DASH) { |
| 5229 | ++i; |
| 5230 | ++this._dashes; |
| 5231 | } else { |
| 5232 | if (this._dashes) { |
| 5233 | buf = B_ONEDASH; |
| 5234 | } |
| 5235 | this._dashes = 0; |
| 5236 | break; |
| 5237 | } |
| 5238 | } |
| 5239 | if (this._dashes === 2) { |
| 5240 | if (start + i < end && this.listenerCount("trailer") !== 0) { |
| 5241 | this.emit("trailer", data.slice(start + i, end)); |
| 5242 | } |
| 5243 | this.reset(); |
| 5244 | this._finished = true; |
| 5245 | if (self._parts === 0) { |
| 5246 | self._realFinish = true; |
| 5247 | self.emit("finish"); |
| 5248 | self._realFinish = false; |
| 5249 | } |
| 5250 | } |
| 5251 | if (this._dashes) { |
| 5252 | return; |
| 5253 | } |
| 5254 | } |
| 5255 | if (this._justMatched) { |
| 5256 | this._justMatched = false; |
| 5257 | } |
| 5258 | if (!this._part) { |
| 5259 | this._part = new PartStream(this._partOpts); |
| 5260 | this._part._read = function(n) { |
| 5261 | self._unpause(); |
| 5262 | }; |
| 5263 | if (this._isPreamble && this.listenerCount("preamble") !== 0) { |
| 5264 | this.emit("preamble", this._part); |
| 5265 | } else if (this._isPreamble !== true && this.listenerCount("part") !== 0) { |
| 5266 | this.emit("part", this._part); |
| 5267 | } else { |
| 5268 | this._ignore(); |
| 5269 | } |
| 5270 | if (!this._isPreamble) { |
| 5271 | this._inHeader = true; |
| 5272 | } |
| 5273 | } |
| 5274 | if (data && start < end && !this._ignoreData) { |
| 5275 | if (this._isPreamble || !this._inHeader) { |
| 5276 | if (buf) { |
| 5277 | shouldWriteMore = this._part.push(buf); |
| 5278 | } |
| 5279 | shouldWriteMore = this._part.push(data.slice(start, end)); |
| 5280 | if (!shouldWriteMore) { |
| 5281 | this._pause = true; |
| 5282 | } |
| 5283 | } else if (!this._isPreamble && this._inHeader) { |
| 5284 | if (buf) { |
| 5285 | this._hparser.push(buf); |
| 5286 | } |
| 5287 | r = this._hparser.push(data.slice(start, end)); |
| 5288 | if (!this._inHeader && r !== void 0 && r < end) { |
| 5289 | this._oninfo(false, data, start + r, end); |
| 5290 | } |
| 5291 | } |
| 5292 | } |
| 5293 | if (isMatch) { |
| 5294 | this._hparser.reset(); |
| 5295 | if (this._isPreamble) { |
| 5296 | this._isPreamble = false; |
| 5297 | } else { |
| 5298 | if (start !== end) { |
| 5299 | ++this._parts; |
| 5300 | this._part.on("end", function() { |
| 5301 | if (--self._parts === 0) { |
| 5302 | if (self._finished) { |
| 5303 | self._realFinish = true; |
| 5304 | self.emit("finish"); |
| 5305 | self._realFinish = false; |
| 5306 | } else { |
| 5307 | self._unpause(); |
| 5308 | } |
| 5309 | } |
| 5310 | }); |
| 5311 | } |
| 5312 | } |
| 5313 | this._part.push(null); |
| 5314 | this._part = void 0; |
| 5315 | this._ignoreData = false; |
| 5316 | this._justMatched = true; |
| 5317 | this._dashes = 0; |
| 5318 | } |
| 5319 | }; |
| 5320 | Dicer.prototype._unpause = function() { |
| 5321 | if (!this._pause) { |
| 5322 | return; |
| 5323 | } |
| 5324 | this._pause = false; |
| 5325 | if (this._cb) { |
| 5326 | const cb = this._cb; |
| 5327 | this._cb = void 0; |
| 5328 | cb(); |
| 5329 | } |
| 5330 | }; |
| 5331 | module2.exports = Dicer; |
| 5332 | } |
| 5333 | }); |
| 5334 | |
| 5335 | // node_modules/.pnpm/@fastify+busboy@2.1.1/node_modules/@fastify/busboy/lib/utils/decodeText.js |
| 5336 | var require_decodeText = __commonJS({ |
| 5337 | "node_modules/.pnpm/@fastify+busboy@2.1.1/node_modules/@fastify/busboy/lib/utils/decodeText.js"(exports2, module2) { |
| 5338 | "use strict"; |
| 5339 | var utf8Decoder = new TextDecoder("utf-8"); |
| 5340 | var textDecoders = /* @__PURE__ */ new Map([ |
| 5341 | ["utf-8", utf8Decoder], |
| 5342 | ["utf8", utf8Decoder] |
| 5343 | ]); |
| 5344 | function getDecoder(charset) { |
| 5345 | let lc; |
| 5346 | while (true) { |
| 5347 | switch (charset) { |
| 5348 | case "utf-8": |
| 5349 | case "utf8": |
| 5350 | return decoders.utf8; |
| 5351 | case "latin1": |
| 5352 | case "ascii": |
| 5353 | case "us-ascii": |
| 5354 | case "iso-8859-1": |
| 5355 | case "iso8859-1": |
| 5356 | case "iso88591": |
| 5357 | case "iso_8859-1": |
| 5358 | case "windows-1252": |
| 5359 | case "iso_8859-1:1987": |
| 5360 | case "cp1252": |
| 5361 | case "x-cp1252": |
| 5362 | return decoders.latin1; |
| 5363 | case "utf16le": |
| 5364 | case "utf-16le": |
| 5365 | case "ucs2": |
| 5366 | case "ucs-2": |
| 5367 | return decoders.utf16le; |
| 5368 | case "base64": |
| 5369 | return decoders.base64; |
| 5370 | default: |
| 5371 | if (lc === void 0) { |
| 5372 | lc = true; |
| 5373 | charset = charset.toLowerCase(); |
| 5374 | continue; |
| 5375 | } |
| 5376 | return decoders.other.bind(charset); |
| 5377 | } |
| 5378 | } |
| 5379 | } |
| 5380 | var decoders = { |
| 5381 | utf8: (data, sourceEncoding) => { |
| 5382 | if (data.length === 0) { |
| 5383 | return ""; |
| 5384 | } |
| 5385 | if (typeof data === "string") { |
| 5386 | data = Buffer.from(data, sourceEncoding); |
| 5387 | } |
| 5388 | return data.utf8Slice(0, data.length); |
| 5389 | }, |
| 5390 | latin1: (data, sourceEncoding) => { |
| 5391 | if (data.length === 0) { |
| 5392 | return ""; |
| 5393 | } |
| 5394 | if (typeof data === "string") { |
| 5395 | return data; |
| 5396 | } |
| 5397 | return data.latin1Slice(0, data.length); |
| 5398 | }, |
| 5399 | utf16le: (data, sourceEncoding) => { |
| 5400 | if (data.length === 0) { |
| 5401 | return ""; |
| 5402 | } |
| 5403 | if (typeof data === "string") { |
| 5404 | data = Buffer.from(data, sourceEncoding); |
| 5405 | } |
| 5406 | return data.ucs2Slice(0, data.length); |
| 5407 | }, |
| 5408 | base64: (data, sourceEncoding) => { |
| 5409 | if (data.length === 0) { |
| 5410 | return ""; |
| 5411 | } |
| 5412 | if (typeof data === "string") { |
| 5413 | data = Buffer.from(data, sourceEncoding); |
| 5414 | } |
| 5415 | return data.base64Slice(0, data.length); |
| 5416 | }, |
| 5417 | other: (data, sourceEncoding) => { |
| 5418 | if (data.length === 0) { |
| 5419 | return ""; |
| 5420 | } |
| 5421 | if (typeof data === "string") { |
| 5422 | data = Buffer.from(data, sourceEncoding); |
| 5423 | } |
| 5424 | if (textDecoders.has(exports2.toString())) { |
| 5425 | try { |
| 5426 | return textDecoders.get(exports2).decode(data); |
| 5427 | } catch { |
| 5428 | } |
| 5429 | } |
| 5430 | return typeof data === "string" ? data : data.toString(); |
| 5431 | } |
| 5432 | }; |
| 5433 | function decodeText(text, sourceEncoding, destEncoding) { |
| 5434 | if (text) { |
| 5435 | return getDecoder(destEncoding)(text, sourceEncoding); |
| 5436 | } |
| 5437 | return text; |
| 5438 | } |
| 5439 | module2.exports = decodeText; |
| 5440 | } |
| 5441 | }); |
| 5442 | |
| 5443 | // node_modules/.pnpm/@fastify+busboy@2.1.1/node_modules/@fastify/busboy/lib/utils/parseParams.js |
| 5444 | var require_parseParams = __commonJS({ |
| 5445 | "node_modules/.pnpm/@fastify+busboy@2.1.1/node_modules/@fastify/busboy/lib/utils/parseParams.js"(exports2, module2) { |
| 5446 | "use strict"; |
| 5447 | var decodeText = require_decodeText(); |
| 5448 | var RE_ENCODED = /%[a-fA-F0-9][a-fA-F0-9]/g; |
| 5449 | var EncodedLookup = { |
| 5450 | "%00": "\0", |
| 5451 | "%01": "", |
| 5452 | "%02": "", |
| 5453 | "%03": "", |
| 5454 | "%04": "", |
| 5455 | "%05": "", |
| 5456 | "%06": "", |
| 5457 | "%07": "\x07", |
| 5458 | "%08": "\b", |
| 5459 | "%09": " ", |
| 5460 | "%0a": "\n", |
| 5461 | "%0A": "\n", |
| 5462 | "%0b": "\v", |
| 5463 | "%0B": "\v", |
| 5464 | "%0c": "\f", |
| 5465 | "%0C": "\f", |
| 5466 | "%0d": "\r", |
| 5467 | "%0D": "\r", |
| 5468 | "%0e": "", |
| 5469 | "%0E": "", |
| 5470 | "%0f": "", |
| 5471 | "%0F": "", |
| 5472 | "%10": "", |
| 5473 | "%11": "", |
| 5474 | "%12": "", |
| 5475 | "%13": "", |
| 5476 | "%14": "", |
| 5477 | "%15": "", |
| 5478 | "%16": "", |
| 5479 | "%17": "", |
| 5480 | "%18": "", |
| 5481 | "%19": "", |
| 5482 | "%1a": "", |
| 5483 | "%1A": "", |
| 5484 | "%1b": "\x1B", |
| 5485 | "%1B": "\x1B", |
| 5486 | "%1c": " ", |
| 5487 | "%1C": " ", |
| 5488 | "%1d": " ", |
| 5489 | "%1D": " ", |
| 5490 | "%1e": " ", |
| 5491 | "%1E": " ", |
| 5492 | "%1f": " ", |
| 5493 | "%1F": " ", |
| 5494 | "%20": " ", |
| 5495 | "%21": "!", |
| 5496 | "%22": '"', |
| 5497 | "%23": "#", |
| 5498 | "%24": "$", |
| 5499 | "%25": "%", |
| 5500 | "%26": "&", |
| 5501 | "%27": "'", |
| 5502 | "%28": "(", |
| 5503 | "%29": ")", |
| 5504 | "%2a": "*", |
| 5505 | "%2A": "*", |
| 5506 | "%2b": "+", |
| 5507 | "%2B": "+", |
| 5508 | "%2c": ",", |
| 5509 | "%2C": ",", |
| 5510 | "%2d": "-", |
| 5511 | "%2D": "-", |
| 5512 | "%2e": ".", |
| 5513 | "%2E": ".", |
| 5514 | "%2f": "/", |
| 5515 | "%2F": "/", |
| 5516 | "%30": "0", |
| 5517 | "%31": "1", |
| 5518 | "%32": "2", |
| 5519 | "%33": "3", |
| 5520 | "%34": "4", |
| 5521 | "%35": "5", |
| 5522 | "%36": "6", |
| 5523 | "%37": "7", |
| 5524 | "%38": "8", |
| 5525 | "%39": "9", |
| 5526 | "%3a": ":", |
| 5527 | "%3A": ":", |
| 5528 | "%3b": ";", |
| 5529 | "%3B": ";", |
| 5530 | "%3c": "<", |
| 5531 | "%3C": "<", |
| 5532 | "%3d": "=", |
| 5533 | "%3D": "=", |
| 5534 | "%3e": ">", |
| 5535 | "%3E": ">", |
| 5536 | "%3f": "?", |
| 5537 | "%3F": "?", |
| 5538 | "%40": "@", |
| 5539 | "%41": "A", |
| 5540 | "%42": "B", |
| 5541 | "%43": "C", |
| 5542 | "%44": "D", |
| 5543 | "%45": "E", |
| 5544 | "%46": "F", |
| 5545 | "%47": "G", |
| 5546 | "%48": "H", |
| 5547 | "%49": "I", |
| 5548 | "%4a": "J", |
| 5549 | "%4A": "J", |
| 5550 | "%4b": "K", |
| 5551 | "%4B": "K", |
| 5552 | "%4c": "L", |
| 5553 | "%4C": "L", |
| 5554 | "%4d": "M", |
| 5555 | "%4D": "M", |
| 5556 | "%4e": "N", |
| 5557 | "%4E": "N", |
| 5558 | "%4f": "O", |
| 5559 | "%4F": "O", |
| 5560 | "%50": "P", |
| 5561 | "%51": "Q", |
| 5562 | "%52": "R", |
| 5563 | "%53": "S", |
| 5564 | "%54": "T", |
| 5565 | "%55": "U", |
| 5566 | "%56": "V", |
| 5567 | "%57": "W", |
| 5568 | "%58": "X", |
| 5569 | "%59": "Y", |
| 5570 | "%5a": "Z", |
| 5571 | "%5A": "Z", |
| 5572 | "%5b": "[", |
| 5573 | "%5B": "[", |
| 5574 | "%5c": "\\", |
| 5575 | "%5C": "\\", |
| 5576 | "%5d": "]", |
| 5577 | "%5D": "]", |
| 5578 | "%5e": "^", |
| 5579 | "%5E": "^", |
| 5580 | "%5f": "_", |
| 5581 | "%5F": "_", |
| 5582 | "%60": "`", |
| 5583 | "%61": "a", |
| 5584 | "%62": "b", |
| 5585 | "%63": "c", |
| 5586 | "%64": "d", |
| 5587 | "%65": "e", |
| 5588 | "%66": "f", |
| 5589 | "%67": "g", |
| 5590 | "%68": "h", |
| 5591 | "%69": "i", |
| 5592 | "%6a": "j", |
| 5593 | "%6A": "j", |
| 5594 | "%6b": "k", |
| 5595 | "%6B": "k", |
| 5596 | "%6c": "l", |
| 5597 | "%6C": "l", |
| 5598 | "%6d": "m", |
| 5599 | "%6D": "m", |
| 5600 | "%6e": "n", |
| 5601 | "%6E": "n", |
| 5602 | "%6f": "o", |
| 5603 | "%6F": "o", |
| 5604 | "%70": "p", |
| 5605 | "%71": "q", |
| 5606 | "%72": "r", |
| 5607 | "%73": "s", |
| 5608 | "%74": "t", |
| 5609 | "%75": "u", |
| 5610 | "%76": "v", |
| 5611 | "%77": "w", |
| 5612 | "%78": "x", |
| 5613 | "%79": "y", |
| 5614 | "%7a": "z", |
| 5615 | "%7A": "z", |
| 5616 | "%7b": "{", |
| 5617 | "%7B": "{", |
| 5618 | "%7c": "|", |
| 5619 | "%7C": "|", |
| 5620 | "%7d": "}", |
| 5621 | "%7D": "}", |
| 5622 | "%7e": "~", |
| 5623 | "%7E": "~", |
| 5624 | "%7f": "\x7F", |
| 5625 | "%7F": "\x7F", |
| 5626 | "%80": "\x80", |
| 5627 | "%81": "\x81", |
| 5628 | "%82": "\x82", |
| 5629 | "%83": "\x83", |
| 5630 | "%84": "\x84", |
| 5631 | "%85": "\x85", |
| 5632 | "%86": "\x86", |
| 5633 | "%87": "\x87", |
| 5634 | "%88": "\x88", |
| 5635 | "%89": "\x89", |
| 5636 | "%8a": "\x8A", |
| 5637 | "%8A": "\x8A", |
| 5638 | "%8b": "\x8B", |
| 5639 | "%8B": "\x8B", |
| 5640 | "%8c": "\x8C", |
| 5641 | "%8C": "\x8C", |
| 5642 | "%8d": "\x8D", |
| 5643 | "%8D": "\x8D", |
| 5644 | "%8e": "\x8E", |
| 5645 | "%8E": "\x8E", |
| 5646 | "%8f": "\x8F", |
| 5647 | "%8F": "\x8F", |
| 5648 | "%90": "\x90", |
| 5649 | "%91": "\x91", |
| 5650 | "%92": "\x92", |
| 5651 | "%93": "\x93", |
| 5652 | "%94": "\x94", |
| 5653 | "%95": "\x95", |
| 5654 | "%96": "\x96", |
| 5655 | "%97": "\x97", |
| 5656 | "%98": "\x98", |
| 5657 | "%99": "\x99", |
| 5658 | "%9a": "\x9A", |
| 5659 | "%9A": "\x9A", |
| 5660 | "%9b": "\x9B", |
| 5661 | "%9B": "\x9B", |
| 5662 | "%9c": "\x9C", |
| 5663 | "%9C": "\x9C", |
| 5664 | "%9d": "\x9D", |
| 5665 | "%9D": "\x9D", |
| 5666 | "%9e": "\x9E", |
| 5667 | "%9E": "\x9E", |
| 5668 | "%9f": "\x9F", |
| 5669 | "%9F": "\x9F", |
| 5670 | "%a0": "\xA0", |
| 5671 | "%A0": "\xA0", |
| 5672 | "%a1": "\xA1", |
| 5673 | "%A1": "\xA1", |
| 5674 | "%a2": "\xA2", |
| 5675 | "%A2": "\xA2", |
| 5676 | "%a3": "\xA3", |
| 5677 | "%A3": "\xA3", |
| 5678 | "%a4": "\xA4", |
| 5679 | "%A4": "\xA4", |
| 5680 | "%a5": "\xA5", |
| 5681 | "%A5": "\xA5", |
| 5682 | "%a6": "\xA6", |
| 5683 | "%A6": "\xA6", |
| 5684 | "%a7": "\xA7", |
| 5685 | "%A7": "\xA7", |
| 5686 | "%a8": "\xA8", |
| 5687 | "%A8": "\xA8", |
| 5688 | "%a9": "\xA9", |
| 5689 | "%A9": "\xA9", |
| 5690 | "%aa": "\xAA", |
| 5691 | "%Aa": "\xAA", |
| 5692 | "%aA": "\xAA", |
| 5693 | "%AA": "\xAA", |
| 5694 | "%ab": "\xAB", |
| 5695 | "%Ab": "\xAB", |
| 5696 | "%aB": "\xAB", |
| 5697 | "%AB": "\xAB", |
| 5698 | "%ac": "\xAC", |
| 5699 | "%Ac": "\xAC", |
| 5700 | "%aC": "\xAC", |
| 5701 | "%AC": "\xAC", |
| 5702 | "%ad": "\xAD", |
| 5703 | "%Ad": "\xAD", |
| 5704 | "%aD": "\xAD", |
| 5705 | "%AD": "\xAD", |
| 5706 | "%ae": "\xAE", |
| 5707 | "%Ae": "\xAE", |
| 5708 | "%aE": "\xAE", |
| 5709 | "%AE": "\xAE", |
| 5710 | "%af": "\xAF", |
| 5711 | "%Af": "\xAF", |
| 5712 | "%aF": "\xAF", |
| 5713 | "%AF": "\xAF", |
| 5714 | "%b0": "\xB0", |
| 5715 | "%B0": "\xB0", |
| 5716 | "%b1": "\xB1", |
| 5717 | "%B1": "\xB1", |
| 5718 | "%b2": "\xB2", |
| 5719 | "%B2": "\xB2", |
| 5720 | "%b3": "\xB3", |
| 5721 | "%B3": "\xB3", |
| 5722 | "%b4": "\xB4", |
| 5723 | "%B4": "\xB4", |
| 5724 | "%b5": "\xB5", |
| 5725 | "%B5": "\xB5", |
| 5726 | "%b6": "\xB6", |
| 5727 | "%B6": "\xB6", |
| 5728 | "%b7": "\xB7", |
| 5729 | "%B7": "\xB7", |
| 5730 | "%b8": "\xB8", |
| 5731 | "%B8": "\xB8", |
| 5732 | "%b9": "\xB9", |
| 5733 | "%B9": "\xB9", |
| 5734 | "%ba": "\xBA", |
| 5735 | "%Ba": "\xBA", |
| 5736 | "%bA": "\xBA", |
| 5737 | "%BA": "\xBA", |
| 5738 | "%bb": "\xBB", |
| 5739 | "%Bb": "\xBB", |
| 5740 | "%bB": "\xBB", |
| 5741 | "%BB": "\xBB", |
| 5742 | "%bc": "\xBC", |
| 5743 | "%Bc": "\xBC", |
| 5744 | "%bC": "\xBC", |
| 5745 | "%BC": "\xBC", |
| 5746 | "%bd": "\xBD", |
| 5747 | "%Bd": "\xBD", |
| 5748 | "%bD": "\xBD", |
| 5749 | "%BD": "\xBD", |
| 5750 | "%be": "\xBE", |
| 5751 | "%Be": "\xBE", |
| 5752 | "%bE": "\xBE", |
| 5753 | "%BE": "\xBE", |
| 5754 | "%bf": "\xBF", |
| 5755 | "%Bf": "\xBF", |
| 5756 | "%bF": "\xBF", |
| 5757 | "%BF": "\xBF", |
| 5758 | "%c0": "\xC0", |
| 5759 | "%C0": "\xC0", |
| 5760 | "%c1": "\xC1", |
| 5761 | "%C1": "\xC1", |
| 5762 | "%c2": "\xC2", |
| 5763 | "%C2": "\xC2", |
| 5764 | "%c3": "\xC3", |
| 5765 | "%C3": "\xC3", |
| 5766 | "%c4": "\xC4", |
| 5767 | "%C4": "\xC4", |
| 5768 | "%c5": "\xC5", |
| 5769 | "%C5": "\xC5", |
| 5770 | "%c6": "\xC6", |
| 5771 | "%C6": "\xC6", |
| 5772 | "%c7": "\xC7", |
| 5773 | "%C7": "\xC7", |
| 5774 | "%c8": "\xC8", |
| 5775 | "%C8": "\xC8", |
| 5776 | "%c9": "\xC9", |
| 5777 | "%C9": "\xC9", |
| 5778 | "%ca": "\xCA", |
| 5779 | "%Ca": "\xCA", |
| 5780 | "%cA": "\xCA", |
| 5781 | "%CA": "\xCA", |
| 5782 | "%cb": "\xCB", |
| 5783 | "%Cb": "\xCB", |
| 5784 | "%cB": "\xCB", |
| 5785 | "%CB": "\xCB", |
| 5786 | "%cc": "\xCC", |
| 5787 | "%Cc": "\xCC", |
| 5788 | "%cC": "\xCC", |
| 5789 | "%CC": "\xCC", |
| 5790 | "%cd": "\xCD", |
| 5791 | "%Cd": "\xCD", |
| 5792 | "%cD": "\xCD", |
| 5793 | "%CD": "\xCD", |
| 5794 | "%ce": "\xCE", |
| 5795 | "%Ce": "\xCE", |
| 5796 | "%cE": "\xCE", |
| 5797 | "%CE": "\xCE", |
| 5798 | "%cf": "\xCF", |
| 5799 | "%Cf": "\xCF", |
| 5800 | "%cF": "\xCF", |
| 5801 | "%CF": "\xCF", |
| 5802 | "%d0": "\xD0", |
| 5803 | "%D0": "\xD0", |
| 5804 | "%d1": "\xD1", |
| 5805 | "%D1": "\xD1", |
| 5806 | "%d2": "\xD2", |
| 5807 | "%D2": "\xD2", |
| 5808 | "%d3": "\xD3", |
| 5809 | "%D3": "\xD3", |
| 5810 | "%d4": "\xD4", |
| 5811 | "%D4": "\xD4", |
| 5812 | "%d5": "\xD5", |
| 5813 | "%D5": "\xD5", |
| 5814 | "%d6": "\xD6", |
| 5815 | "%D6": "\xD6", |
| 5816 | "%d7": "\xD7", |
| 5817 | "%D7": "\xD7", |
| 5818 | "%d8": "\xD8", |
| 5819 | "%D8": "\xD8", |
| 5820 | "%d9": "\xD9", |
| 5821 | "%D9": "\xD9", |
| 5822 | "%da": "\xDA", |
| 5823 | "%Da": "\xDA", |
| 5824 | "%dA": "\xDA", |
| 5825 | "%DA": "\xDA", |
| 5826 | "%db": "\xDB", |
| 5827 | "%Db": "\xDB", |
| 5828 | "%dB": "\xDB", |
| 5829 | "%DB": "\xDB", |
| 5830 | "%dc": "\xDC", |
| 5831 | "%Dc": "\xDC", |
| 5832 | "%dC": "\xDC", |
| 5833 | "%DC": "\xDC", |
| 5834 | "%dd": "\xDD", |
| 5835 | "%Dd": "\xDD", |
| 5836 | "%dD": "\xDD", |
| 5837 | "%DD": "\xDD", |
| 5838 | "%de": "\xDE", |
| 5839 | "%De": "\xDE", |
| 5840 | "%dE": "\xDE", |
| 5841 | "%DE": "\xDE", |
| 5842 | "%df": "\xDF", |
| 5843 | "%Df": "\xDF", |
| 5844 | "%dF": "\xDF", |
| 5845 | "%DF": "\xDF", |
| 5846 | "%e0": "\xE0", |
| 5847 | "%E0": "\xE0", |
| 5848 | "%e1": "\xE1", |
| 5849 | "%E1": "\xE1", |
| 5850 | "%e2": "\xE2", |
| 5851 | "%E2": "\xE2", |
| 5852 | "%e3": "\xE3", |
| 5853 | "%E3": "\xE3", |
| 5854 | "%e4": "\xE4", |
| 5855 | "%E4": "\xE4", |
| 5856 | "%e5": "\xE5", |
| 5857 | "%E5": "\xE5", |
| 5858 | "%e6": "\xE6", |
| 5859 | "%E6": "\xE6", |
| 5860 | "%e7": "\xE7", |
| 5861 | "%E7": "\xE7", |
| 5862 | "%e8": "\xE8", |
| 5863 | "%E8": "\xE8", |
| 5864 | "%e9": "\xE9", |
| 5865 | "%E9": "\xE9", |
| 5866 | "%ea": "\xEA", |
| 5867 | "%Ea": "\xEA", |
| 5868 | "%eA": "\xEA", |
| 5869 | "%EA": "\xEA", |
| 5870 | "%eb": "\xEB", |
| 5871 | "%Eb": "\xEB", |
| 5872 | "%eB": "\xEB", |
| 5873 | "%EB": "\xEB", |
| 5874 | "%ec": "\xEC", |
| 5875 | "%Ec": "\xEC", |
| 5876 | "%eC": "\xEC", |
| 5877 | "%EC": "\xEC", |
| 5878 | "%ed": "\xED", |
| 5879 | "%Ed": "\xED", |
| 5880 | "%eD": "\xED", |
| 5881 | "%ED": "\xED", |
| 5882 | "%ee": "\xEE", |
| 5883 | "%Ee": "\xEE", |
| 5884 | "%eE": "\xEE", |
| 5885 | "%EE": "\xEE", |
| 5886 | "%ef": "\xEF", |
| 5887 | "%Ef": "\xEF", |
| 5888 | "%eF": "\xEF", |
| 5889 | "%EF": "\xEF", |
| 5890 | "%f0": "\xF0", |
| 5891 | "%F0": "\xF0", |
| 5892 | "%f1": "\xF1", |
| 5893 | "%F1": "\xF1", |
| 5894 | "%f2": "\xF2", |
| 5895 | "%F2": "\xF2", |
| 5896 | "%f3": "\xF3", |
| 5897 | "%F3": "\xF3", |
| 5898 | "%f4": "\xF4", |
| 5899 | "%F4": "\xF4", |
| 5900 | "%f5": "\xF5", |
| 5901 | "%F5": "\xF5", |
| 5902 | "%f6": "\xF6", |
| 5903 | "%F6": "\xF6", |
| 5904 | "%f7": "\xF7", |
| 5905 | "%F7": "\xF7", |
| 5906 | "%f8": "\xF8", |
| 5907 | "%F8": "\xF8", |
| 5908 | "%f9": "\xF9", |
| 5909 | "%F9": "\xF9", |
| 5910 | "%fa": "\xFA", |
| 5911 | "%Fa": "\xFA", |
| 5912 | "%fA": "\xFA", |
| 5913 | "%FA": "\xFA", |
| 5914 | "%fb": "\xFB", |
| 5915 | "%Fb": "\xFB", |
| 5916 | "%fB": "\xFB", |
| 5917 | "%FB": "\xFB", |
| 5918 | "%fc": "\xFC", |
| 5919 | "%Fc": "\xFC", |
| 5920 | "%fC": "\xFC", |
| 5921 | "%FC": "\xFC", |
| 5922 | "%fd": "\xFD", |
| 5923 | "%Fd": "\xFD", |
| 5924 | "%fD": "\xFD", |
| 5925 | "%FD": "\xFD", |
| 5926 | "%fe": "\xFE", |
| 5927 | "%Fe": "\xFE", |
| 5928 | "%fE": "\xFE", |
| 5929 | "%FE": "\xFE", |
| 5930 | "%ff": "\xFF", |
| 5931 | "%Ff": "\xFF", |
| 5932 | "%fF": "\xFF", |
| 5933 | "%FF": "\xFF" |
| 5934 | }; |
| 5935 | function encodedReplacer(match) { |
| 5936 | return EncodedLookup[match]; |
| 5937 | } |
| 5938 | var STATE_KEY = 0; |
| 5939 | var STATE_VALUE = 1; |
| 5940 | var STATE_CHARSET = 2; |
| 5941 | var STATE_LANG = 3; |
| 5942 | function parseParams(str) { |
| 5943 | const res = []; |
| 5944 | let state = STATE_KEY; |
| 5945 | let charset = ""; |
| 5946 | let inquote = false; |
| 5947 | let escaping = false; |
| 5948 | let p = 0; |
| 5949 | let tmp = ""; |
| 5950 | const len = str.length; |
| 5951 | for (var i = 0; i < len; ++i) { |
| 5952 | const char = str[i]; |
| 5953 | if (char === "\\" && inquote) { |
| 5954 | if (escaping) { |
| 5955 | escaping = false; |
| 5956 | } else { |
| 5957 | escaping = true; |
| 5958 | continue; |
| 5959 | } |
| 5960 | } else if (char === '"') { |
| 5961 | if (!escaping) { |
| 5962 | if (inquote) { |
| 5963 | inquote = false; |
| 5964 | state = STATE_KEY; |
| 5965 | } else { |
| 5966 | inquote = true; |
| 5967 | } |
| 5968 | continue; |
| 5969 | } else { |
| 5970 | escaping = false; |
| 5971 | } |
| 5972 | } else { |
| 5973 | if (escaping && inquote) { |
| 5974 | tmp += "\\"; |
| 5975 | } |
| 5976 | escaping = false; |
| 5977 | if ((state === STATE_CHARSET || state === STATE_LANG) && char === "'") { |
| 5978 | if (state === STATE_CHARSET) { |
| 5979 | state = STATE_LANG; |
| 5980 | charset = tmp.substring(1); |
| 5981 | } else { |
| 5982 | state = STATE_VALUE; |
| 5983 | } |
| 5984 | tmp = ""; |
| 5985 | continue; |
| 5986 | } else if (state === STATE_KEY && (char === "*" || char === "=") && res.length) { |
| 5987 | state = char === "*" ? STATE_CHARSET : STATE_VALUE; |
| 5988 | res[p] = [tmp, void 0]; |
| 5989 | tmp = ""; |
| 5990 | continue; |
| 5991 | } else if (!inquote && char === ";") { |
| 5992 | state = STATE_KEY; |
| 5993 | if (charset) { |
| 5994 | if (tmp.length) { |
| 5995 | tmp = decodeText( |
| 5996 | tmp.replace(RE_ENCODED, encodedReplacer), |
| 5997 | "binary", |
| 5998 | charset |
| 5999 | ); |
| 6000 | } |
| 6001 | charset = ""; |
| 6002 | } else if (tmp.length) { |
| 6003 | tmp = decodeText(tmp, "binary", "utf8"); |
| 6004 | } |
| 6005 | if (res[p] === void 0) { |
| 6006 | res[p] = tmp; |
| 6007 | } else { |
| 6008 | res[p][1] = tmp; |
| 6009 | } |
| 6010 | tmp = ""; |
| 6011 | ++p; |
| 6012 | continue; |
| 6013 | } else if (!inquote && (char === " " || char === " ")) { |
| 6014 | continue; |
| 6015 | } |
| 6016 | } |
| 6017 | tmp += char; |
| 6018 | } |
| 6019 | if (charset && tmp.length) { |
| 6020 | tmp = decodeText( |
| 6021 | tmp.replace(RE_ENCODED, encodedReplacer), |
| 6022 | "binary", |
| 6023 | charset |
| 6024 | ); |
| 6025 | } else if (tmp) { |
| 6026 | tmp = decodeText(tmp, "binary", "utf8"); |
| 6027 | } |
| 6028 | if (res[p] === void 0) { |
| 6029 | if (tmp) { |
| 6030 | res[p] = tmp; |
| 6031 | } |
| 6032 | } else { |
| 6033 | res[p][1] = tmp; |
| 6034 | } |
| 6035 | return res; |
| 6036 | } |
| 6037 | module2.exports = parseParams; |
| 6038 | } |
| 6039 | }); |
| 6040 | |
| 6041 | // node_modules/.pnpm/@fastify+busboy@2.1.1/node_modules/@fastify/busboy/lib/utils/basename.js |
| 6042 | var require_basename = __commonJS({ |
| 6043 | "node_modules/.pnpm/@fastify+busboy@2.1.1/node_modules/@fastify/busboy/lib/utils/basename.js"(exports2, module2) { |
| 6044 | "use strict"; |
| 6045 | module2.exports = function basename(path5) { |
| 6046 | if (typeof path5 !== "string") { |
| 6047 | return ""; |
| 6048 | } |
| 6049 | for (var i = path5.length - 1; i >= 0; --i) { |
| 6050 | switch (path5.charCodeAt(i)) { |
| 6051 | case 47: |
| 6052 | case 92: |
| 6053 | path5 = path5.slice(i + 1); |
| 6054 | return path5 === ".." || path5 === "." ? "" : path5; |
| 6055 | } |
| 6056 | } |
| 6057 | return path5 === ".." || path5 === "." ? "" : path5; |
| 6058 | }; |
| 6059 | } |
| 6060 | }); |
| 6061 | |
| 6062 | // node_modules/.pnpm/@fastify+busboy@2.1.1/node_modules/@fastify/busboy/lib/types/multipart.js |
| 6063 | var require_multipart = __commonJS({ |
| 6064 | "node_modules/.pnpm/@fastify+busboy@2.1.1/node_modules/@fastify/busboy/lib/types/multipart.js"(exports2, module2) { |
| 6065 | "use strict"; |
| 6066 | var { Readable } = require("node:stream"); |
| 6067 | var { inherits } = require("node:util"); |
| 6068 | var Dicer = require_Dicer(); |
| 6069 | var parseParams = require_parseParams(); |
| 6070 | var decodeText = require_decodeText(); |
| 6071 | var basename = require_basename(); |
| 6072 | var getLimit = require_getLimit(); |
| 6073 | var RE_BOUNDARY = /^boundary$/i; |
| 6074 | var RE_FIELD = /^form-data$/i; |
| 6075 | var RE_CHARSET = /^charset$/i; |
| 6076 | var RE_FILENAME = /^filename$/i; |
| 6077 | var RE_NAME = /^name$/i; |
| 6078 | Multipart.detect = /^multipart\/form-data/i; |
| 6079 | function Multipart(boy, cfg) { |
| 6080 | let i; |
| 6081 | let len; |
| 6082 | const self = this; |
| 6083 | let boundary; |
| 6084 | const limits = cfg.limits; |
| 6085 | const isPartAFile = cfg.isPartAFile || ((fieldName, contentType, fileName) => contentType === "application/octet-stream" || fileName !== void 0); |
| 6086 | const parsedConType = cfg.parsedConType || []; |
| 6087 | const defCharset = cfg.defCharset || "utf8"; |
| 6088 | const preservePath = cfg.preservePath; |
| 6089 | const fileOpts = { highWaterMark: cfg.fileHwm }; |
| 6090 | for (i = 0, len = parsedConType.length; i < len; ++i) { |
| 6091 | if (Array.isArray(parsedConType[i]) && RE_BOUNDARY.test(parsedConType[i][0])) { |
| 6092 | boundary = parsedConType[i][1]; |
| 6093 | break; |
| 6094 | } |
| 6095 | } |
| 6096 | function checkFinished() { |
| 6097 | if (nends === 0 && finished && !boy._done) { |
| 6098 | finished = false; |
| 6099 | self.end(); |
| 6100 | } |
| 6101 | } |
| 6102 | if (typeof boundary !== "string") { |
| 6103 | throw new Error("Multipart: Boundary not found"); |
| 6104 | } |
| 6105 | const fieldSizeLimit = getLimit(limits, "fieldSize", 1 * 1024 * 1024); |
| 6106 | const fileSizeLimit = getLimit(limits, "fileSize", Infinity); |
| 6107 | const filesLimit = getLimit(limits, "files", Infinity); |
| 6108 | const fieldsLimit = getLimit(limits, "fields", Infinity); |
| 6109 | const partsLimit = getLimit(limits, "parts", Infinity); |
| 6110 | const headerPairsLimit = getLimit(limits, "headerPairs", 2e3); |
| 6111 | const headerSizeLimit = getLimit(limits, "headerSize", 80 * 1024); |
| 6112 | let nfiles = 0; |
| 6113 | let nfields = 0; |
| 6114 | let nends = 0; |
| 6115 | let curFile; |
| 6116 | let curField; |
| 6117 | let finished = false; |
| 6118 | this._needDrain = false; |
| 6119 | this._pause = false; |
| 6120 | this._cb = void 0; |
| 6121 | this._nparts = 0; |
| 6122 | this._boy = boy; |
| 6123 | const parserCfg = { |
| 6124 | boundary, |
| 6125 | maxHeaderPairs: headerPairsLimit, |
| 6126 | maxHeaderSize: headerSizeLimit, |
| 6127 | partHwm: fileOpts.highWaterMark, |
| 6128 | highWaterMark: cfg.highWaterMark |
| 6129 | }; |
| 6130 | this.parser = new Dicer(parserCfg); |
| 6131 | this.parser.on("drain", function() { |
| 6132 | self._needDrain = false; |
| 6133 | if (self._cb && !self._pause) { |
| 6134 | const cb = self._cb; |
| 6135 | self._cb = void 0; |
| 6136 | cb(); |
| 6137 | } |
| 6138 | }).on("part", function onPart(part) { |
| 6139 | if (++self._nparts > partsLimit) { |
| 6140 | self.parser.removeListener("part", onPart); |
| 6141 | self.parser.on("part", skipPart); |
| 6142 | boy.hitPartsLimit = true; |
| 6143 | boy.emit("partsLimit"); |
| 6144 | return skipPart(part); |
| 6145 | } |
| 6146 | if (curField) { |
| 6147 | const field = curField; |
| 6148 | field.emit("end"); |
| 6149 | field.removeAllListeners("end"); |
| 6150 | } |
| 6151 | part.on("header", function(header) { |
| 6152 | let contype; |
| 6153 | let fieldname; |
| 6154 | let parsed; |
| 6155 | let charset; |
| 6156 | let encoding; |
| 6157 | let filename; |
| 6158 | let nsize = 0; |
| 6159 | if (header["content-type"]) { |
| 6160 | parsed = parseParams(header["content-type"][0]); |
| 6161 | if (parsed[0]) { |
| 6162 | contype = parsed[0].toLowerCase(); |
| 6163 | for (i = 0, len = parsed.length; i < len; ++i) { |
| 6164 | if (RE_CHARSET.test(parsed[i][0])) { |
| 6165 | charset = parsed[i][1].toLowerCase(); |
| 6166 | break; |
| 6167 | } |
| 6168 | } |
| 6169 | } |
| 6170 | } |
| 6171 | if (contype === void 0) { |
| 6172 | contype = "text/plain"; |
| 6173 | } |
| 6174 | if (charset === void 0) { |
| 6175 | charset = defCharset; |
| 6176 | } |
| 6177 | if (header["content-disposition"]) { |
| 6178 | parsed = parseParams(header["content-disposition"][0]); |
| 6179 | if (!RE_FIELD.test(parsed[0])) { |
| 6180 | return skipPart(part); |
| 6181 | } |
| 6182 | for (i = 0, len = parsed.length; i < len; ++i) { |
| 6183 | if (RE_NAME.test(parsed[i][0])) { |
| 6184 | fieldname = parsed[i][1]; |
| 6185 | } else if (RE_FILENAME.test(parsed[i][0])) { |
| 6186 | filename = parsed[i][1]; |
| 6187 | if (!preservePath) { |
| 6188 | filename = basename(filename); |
| 6189 | } |
| 6190 | } |
| 6191 | } |
| 6192 | } else { |
| 6193 | return skipPart(part); |
| 6194 | } |
| 6195 | if (header["content-transfer-encoding"]) { |
| 6196 | encoding = header["content-transfer-encoding"][0].toLowerCase(); |
| 6197 | } else { |
| 6198 | encoding = "7bit"; |
| 6199 | } |
| 6200 | let onData, onEnd; |
| 6201 | if (isPartAFile(fieldname, contype, filename)) { |
| 6202 | if (nfiles === filesLimit) { |
| 6203 | if (!boy.hitFilesLimit) { |
| 6204 | boy.hitFilesLimit = true; |
| 6205 | boy.emit("filesLimit"); |
| 6206 | } |
| 6207 | return skipPart(part); |
| 6208 | } |
| 6209 | ++nfiles; |
| 6210 | if (boy.listenerCount("file") === 0) { |
| 6211 | self.parser._ignore(); |
| 6212 | return; |
| 6213 | } |
| 6214 | ++nends; |
| 6215 | const file = new FileStream(fileOpts); |
| 6216 | curFile = file; |
| 6217 | file.on("end", function() { |
| 6218 | --nends; |
| 6219 | self._pause = false; |
| 6220 | checkFinished(); |
| 6221 | if (self._cb && !self._needDrain) { |
| 6222 | const cb = self._cb; |
| 6223 | self._cb = void 0; |
| 6224 | cb(); |
| 6225 | } |
| 6226 | }); |
| 6227 | file._read = function(n) { |
| 6228 | if (!self._pause) { |
| 6229 | return; |
| 6230 | } |
| 6231 | self._pause = false; |
| 6232 | if (self._cb && !self._needDrain) { |
| 6233 | const cb = self._cb; |
| 6234 | self._cb = void 0; |
| 6235 | cb(); |
| 6236 | } |
| 6237 | }; |
| 6238 | boy.emit("file", fieldname, file, filename, encoding, contype); |
| 6239 | onData = function(data) { |
| 6240 | if ((nsize += data.length) > fileSizeLimit) { |
| 6241 | const extralen = fileSizeLimit - nsize + data.length; |
| 6242 | if (extralen > 0) { |
| 6243 | file.push(data.slice(0, extralen)); |
| 6244 | } |
| 6245 | file.truncated = true; |
| 6246 | file.bytesRead = fileSizeLimit; |
| 6247 | part.removeAllListeners("data"); |
| 6248 | file.emit("limit"); |
| 6249 | return; |
| 6250 | } else if (!file.push(data)) { |
| 6251 | self._pause = true; |
| 6252 | } |
| 6253 | file.bytesRead = nsize; |
| 6254 | }; |
| 6255 | onEnd = function() { |
| 6256 | curFile = void 0; |
| 6257 | file.push(null); |
| 6258 | }; |
| 6259 | } else { |
| 6260 | if (nfields === fieldsLimit) { |
| 6261 | if (!boy.hitFieldsLimit) { |
| 6262 | boy.hitFieldsLimit = true; |
| 6263 | boy.emit("fieldsLimit"); |
| 6264 | } |
| 6265 | return skipPart(part); |
| 6266 | } |
| 6267 | ++nfields; |
| 6268 | ++nends; |
| 6269 | let buffer = ""; |
| 6270 | let truncated = false; |
| 6271 | curField = part; |
| 6272 | onData = function(data) { |
| 6273 | if ((nsize += data.length) > fieldSizeLimit) { |
| 6274 | const extralen = fieldSizeLimit - (nsize - data.length); |
| 6275 | buffer += data.toString("binary", 0, extralen); |
| 6276 | truncated = true; |
| 6277 | part.removeAllListeners("data"); |
| 6278 | } else { |
| 6279 | buffer += data.toString("binary"); |
| 6280 | } |
| 6281 | }; |
| 6282 | onEnd = function() { |
| 6283 | curField = void 0; |
| 6284 | if (buffer.length) { |
| 6285 | buffer = decodeText(buffer, "binary", charset); |
| 6286 | } |
| 6287 | boy.emit("field", fieldname, buffer, false, truncated, encoding, contype); |
| 6288 | --nends; |
| 6289 | checkFinished(); |
| 6290 | }; |
| 6291 | } |
| 6292 | part._readableState.sync = false; |
| 6293 | part.on("data", onData); |
| 6294 | part.on("end", onEnd); |
| 6295 | }).on("error", function(err) { |
| 6296 | if (curFile) { |
| 6297 | curFile.emit("error", err); |
| 6298 | } |
| 6299 | }); |
| 6300 | }).on("error", function(err) { |
| 6301 | boy.emit("error", err); |
| 6302 | }).on("finish", function() { |
| 6303 | finished = true; |
| 6304 | checkFinished(); |
| 6305 | }); |
| 6306 | } |
| 6307 | Multipart.prototype.write = function(chunk, cb) { |
| 6308 | const r = this.parser.write(chunk); |
| 6309 | if (r && !this._pause) { |
| 6310 | cb(); |
| 6311 | } else { |
| 6312 | this._needDrain = !r; |
| 6313 | this._cb = cb; |
| 6314 | } |
| 6315 | }; |
| 6316 | Multipart.prototype.end = function() { |
| 6317 | const self = this; |
| 6318 | if (self.parser.writable) { |
| 6319 | self.parser.end(); |
| 6320 | } else if (!self._boy._done) { |
| 6321 | process.nextTick(function() { |
| 6322 | self._boy._done = true; |
| 6323 | self._boy.emit("finish"); |
| 6324 | }); |
| 6325 | } |
| 6326 | }; |
| 6327 | function skipPart(part) { |
| 6328 | part.resume(); |
| 6329 | } |
| 6330 | function FileStream(opts) { |
| 6331 | Readable.call(this, opts); |
| 6332 | this.bytesRead = 0; |
| 6333 | this.truncated = false; |
| 6334 | } |
| 6335 | inherits(FileStream, Readable); |
| 6336 | FileStream.prototype._read = function(n) { |
| 6337 | }; |
| 6338 | module2.exports = Multipart; |
| 6339 | } |
| 6340 | }); |
| 6341 | |
| 6342 | // node_modules/.pnpm/@fastify+busboy@2.1.1/node_modules/@fastify/busboy/lib/utils/Decoder.js |
| 6343 | var require_Decoder = __commonJS({ |
| 6344 | "node_modules/.pnpm/@fastify+busboy@2.1.1/node_modules/@fastify/busboy/lib/utils/Decoder.js"(exports2, module2) { |
| 6345 | "use strict"; |
| 6346 | var RE_PLUS = /\+/g; |
| 6347 | var HEX = [ |
| 6348 | 0, |
| 6349 | 0, |
| 6350 | 0, |
| 6351 | 0, |
| 6352 | 0, |
| 6353 | 0, |
| 6354 | 0, |
| 6355 | 0, |
| 6356 | 0, |
| 6357 | 0, |
| 6358 | 0, |
| 6359 | 0, |
| 6360 | 0, |
| 6361 | 0, |
| 6362 | 0, |
| 6363 | 0, |
| 6364 | 0, |
| 6365 | 0, |
| 6366 | 0, |
| 6367 | 0, |
| 6368 | 0, |
| 6369 | 0, |
| 6370 | 0, |
| 6371 | 0, |
| 6372 | 0, |
| 6373 | 0, |
| 6374 | 0, |
| 6375 | 0, |
| 6376 | 0, |
| 6377 | 0, |
| 6378 | 0, |
| 6379 | 0, |
| 6380 | 0, |
| 6381 | 0, |
| 6382 | 0, |
| 6383 | 0, |
| 6384 | 0, |
| 6385 | 0, |
| 6386 | 0, |
| 6387 | 0, |
| 6388 | 0, |
| 6389 | 0, |
| 6390 | 0, |
| 6391 | 0, |
| 6392 | 0, |
| 6393 | 0, |
| 6394 | 0, |
| 6395 | 0, |
| 6396 | 1, |
| 6397 | 1, |
| 6398 | 1, |
| 6399 | 1, |
| 6400 | 1, |
| 6401 | 1, |
| 6402 | 1, |
| 6403 | 1, |
| 6404 | 1, |
| 6405 | 1, |
| 6406 | 0, |
| 6407 | 0, |
| 6408 | 0, |
| 6409 | 0, |
| 6410 | 0, |
| 6411 | 0, |
| 6412 | 0, |
| 6413 | 1, |
| 6414 | 1, |
| 6415 | 1, |
| 6416 | 1, |
| 6417 | 1, |
| 6418 | 1, |
| 6419 | 0, |
| 6420 | 0, |
| 6421 | 0, |
| 6422 | 0, |
| 6423 | 0, |
| 6424 | 0, |
| 6425 | 0, |
| 6426 | 0, |
| 6427 | 0, |
| 6428 | 0, |
| 6429 | 0, |
| 6430 | 0, |
| 6431 | 0, |
| 6432 | 0, |
| 6433 | 0, |
| 6434 | 0, |
| 6435 | 0, |
| 6436 | 0, |
| 6437 | 0, |
| 6438 | 0, |
| 6439 | 0, |
| 6440 | 0, |
| 6441 | 0, |
| 6442 | 0, |
| 6443 | 0, |
| 6444 | 0, |
| 6445 | 1, |
| 6446 | 1, |
| 6447 | 1, |
| 6448 | 1, |
| 6449 | 1, |
| 6450 | 1, |
| 6451 | 0, |
| 6452 | 0, |
| 6453 | 0, |
| 6454 | 0, |
| 6455 | 0, |
| 6456 | 0, |
| 6457 | 0, |
| 6458 | 0, |
| 6459 | 0, |
| 6460 | 0, |
| 6461 | 0, |
| 6462 | 0, |
| 6463 | 0, |
| 6464 | 0, |
| 6465 | 0, |
| 6466 | 0, |
| 6467 | 0, |
| 6468 | 0, |
| 6469 | 0, |
| 6470 | 0, |
| 6471 | 0, |
| 6472 | 0, |
| 6473 | 0, |
| 6474 | 0, |
| 6475 | 0 |
| 6476 | ]; |
| 6477 | function Decoder() { |
| 6478 | this.buffer = void 0; |
| 6479 | } |
| 6480 | Decoder.prototype.write = function(str) { |
| 6481 | str = str.replace(RE_PLUS, " "); |
| 6482 | let res = ""; |
| 6483 | let i = 0; |
| 6484 | let p = 0; |
| 6485 | const len = str.length; |
| 6486 | for (; i < len; ++i) { |
| 6487 | if (this.buffer !== void 0) { |
| 6488 | if (!HEX[str.charCodeAt(i)]) { |
| 6489 | res += "%" + this.buffer; |
| 6490 | this.buffer = void 0; |
| 6491 | --i; |
| 6492 | } else { |
| 6493 | this.buffer += str[i]; |
| 6494 | ++p; |
| 6495 | if (this.buffer.length === 2) { |
| 6496 | res += String.fromCharCode(parseInt(this.buffer, 16)); |
| 6497 | this.buffer = void 0; |
| 6498 | } |
| 6499 | } |
| 6500 | } else if (str[i] === "%") { |
| 6501 | if (i > p) { |
| 6502 | res += str.substring(p, i); |
| 6503 | p = i; |
| 6504 | } |
| 6505 | this.buffer = ""; |
| 6506 | ++p; |
| 6507 | } |
| 6508 | } |
| 6509 | if (p < len && this.buffer === void 0) { |
| 6510 | res += str.substring(p); |
| 6511 | } |
| 6512 | return res; |
| 6513 | }; |
| 6514 | Decoder.prototype.reset = function() { |
| 6515 | this.buffer = void 0; |
| 6516 | }; |
| 6517 | module2.exports = Decoder; |
| 6518 | } |
| 6519 | }); |
| 6520 | |
| 6521 | // node_modules/.pnpm/@fastify+busboy@2.1.1/node_modules/@fastify/busboy/lib/types/urlencoded.js |
| 6522 | var require_urlencoded = __commonJS({ |
| 6523 | "node_modules/.pnpm/@fastify+busboy@2.1.1/node_modules/@fastify/busboy/lib/types/urlencoded.js"(exports2, module2) { |
| 6524 | "use strict"; |
| 6525 | var Decoder = require_Decoder(); |
| 6526 | var decodeText = require_decodeText(); |
| 6527 | var getLimit = require_getLimit(); |
| 6528 | var RE_CHARSET = /^charset$/i; |
| 6529 | UrlEncoded.detect = /^application\/x-www-form-urlencoded/i; |
| 6530 | function UrlEncoded(boy, cfg) { |
| 6531 | const limits = cfg.limits; |
| 6532 | const parsedConType = cfg.parsedConType; |
| 6533 | this.boy = boy; |
| 6534 | this.fieldSizeLimit = getLimit(limits, "fieldSize", 1 * 1024 * 1024); |
| 6535 | this.fieldNameSizeLimit = getLimit(limits, "fieldNameSize", 100); |
| 6536 | this.fieldsLimit = getLimit(limits, "fields", Infinity); |
| 6537 | let charset; |
| 6538 | for (var i = 0, len = parsedConType.length; i < len; ++i) { |
| 6539 | if (Array.isArray(parsedConType[i]) && RE_CHARSET.test(parsedConType[i][0])) { |
| 6540 | charset = parsedConType[i][1].toLowerCase(); |
| 6541 | break; |
| 6542 | } |
| 6543 | } |
| 6544 | if (charset === void 0) { |
| 6545 | charset = cfg.defCharset || "utf8"; |
| 6546 | } |
| 6547 | this.decoder = new Decoder(); |
| 6548 | this.charset = charset; |
| 6549 | this._fields = 0; |
| 6550 | this._state = "key"; |
| 6551 | this._checkingBytes = true; |
| 6552 | this._bytesKey = 0; |
| 6553 | this._bytesVal = 0; |
| 6554 | this._key = ""; |
| 6555 | this._val = ""; |
| 6556 | this._keyTrunc = false; |
| 6557 | this._valTrunc = false; |
| 6558 | this._hitLimit = false; |
| 6559 | } |
| 6560 | UrlEncoded.prototype.write = function(data, cb) { |
| 6561 | if (this._fields === this.fieldsLimit) { |
| 6562 | if (!this.boy.hitFieldsLimit) { |
| 6563 | this.boy.hitFieldsLimit = true; |
| 6564 | this.boy.emit("fieldsLimit"); |
| 6565 | } |
| 6566 | return cb(); |
| 6567 | } |
| 6568 | let idxeq; |
| 6569 | let idxamp; |
| 6570 | let i; |
| 6571 | let p = 0; |
| 6572 | const len = data.length; |
| 6573 | while (p < len) { |
| 6574 | if (this._state === "key") { |
| 6575 | idxeq = idxamp = void 0; |
| 6576 | for (i = p; i < len; ++i) { |
| 6577 | if (!this._checkingBytes) { |
| 6578 | ++p; |
| 6579 | } |
| 6580 | if (data[i] === 61) { |
| 6581 | idxeq = i; |
| 6582 | break; |
| 6583 | } else if (data[i] === 38) { |
| 6584 | idxamp = i; |
| 6585 | break; |
| 6586 | } |
| 6587 | if (this._checkingBytes && this._bytesKey === this.fieldNameSizeLimit) { |
| 6588 | this._hitLimit = true; |
| 6589 | break; |
| 6590 | } else if (this._checkingBytes) { |
| 6591 | ++this._bytesKey; |
| 6592 | } |
| 6593 | } |
| 6594 | if (idxeq !== void 0) { |
| 6595 | if (idxeq > p) { |
| 6596 | this._key += this.decoder.write(data.toString("binary", p, idxeq)); |
| 6597 | } |
| 6598 | this._state = "val"; |
| 6599 | this._hitLimit = false; |
| 6600 | this._checkingBytes = true; |
| 6601 | this._val = ""; |
| 6602 | this._bytesVal = 0; |
| 6603 | this._valTrunc = false; |
| 6604 | this.decoder.reset(); |
| 6605 | p = idxeq + 1; |
| 6606 | } else if (idxamp !== void 0) { |
| 6607 | ++this._fields; |
| 6608 | let key; |
| 6609 | const keyTrunc = this._keyTrunc; |
| 6610 | if (idxamp > p) { |
| 6611 | key = this._key += this.decoder.write(data.toString("binary", p, idxamp)); |
| 6612 | } else { |
| 6613 | key = this._key; |
| 6614 | } |
| 6615 | this._hitLimit = false; |
| 6616 | this._checkingBytes = true; |
| 6617 | this._key = ""; |
| 6618 | this._bytesKey = 0; |
| 6619 | this._keyTrunc = false; |
| 6620 | this.decoder.reset(); |
| 6621 | if (key.length) { |
| 6622 | this.boy.emit( |
| 6623 | "field", |
| 6624 | decodeText(key, "binary", this.charset), |
| 6625 | "", |
| 6626 | keyTrunc, |
| 6627 | false |
| 6628 | ); |
| 6629 | } |
| 6630 | p = idxamp + 1; |
| 6631 | if (this._fields === this.fieldsLimit) { |
| 6632 | return cb(); |
| 6633 | } |
| 6634 | } else if (this._hitLimit) { |
| 6635 | if (i > p) { |
| 6636 | this._key += this.decoder.write(data.toString("binary", p, i)); |
| 6637 | } |
| 6638 | p = i; |
| 6639 | if ((this._bytesKey = this._key.length) === this.fieldNameSizeLimit) { |
| 6640 | this._checkingBytes = false; |
| 6641 | this._keyTrunc = true; |
| 6642 | } |
| 6643 | } else { |
| 6644 | if (p < len) { |
| 6645 | this._key += this.decoder.write(data.toString("binary", p)); |
| 6646 | } |
| 6647 | p = len; |
| 6648 | } |
| 6649 | } else { |
| 6650 | idxamp = void 0; |
| 6651 | for (i = p; i < len; ++i) { |
| 6652 | if (!this._checkingBytes) { |
| 6653 | ++p; |
| 6654 | } |
| 6655 | if (data[i] === 38) { |
| 6656 | idxamp = i; |
| 6657 | break; |
| 6658 | } |
| 6659 | if (this._checkingBytes && this._bytesVal === this.fieldSizeLimit) { |
| 6660 | this._hitLimit = true; |
| 6661 | break; |
| 6662 | } else if (this._checkingBytes) { |
| 6663 | ++this._bytesVal; |
| 6664 | } |
| 6665 | } |
| 6666 | if (idxamp !== void 0) { |
| 6667 | ++this._fields; |
| 6668 | if (idxamp > p) { |
| 6669 | this._val += this.decoder.write(data.toString("binary", p, idxamp)); |
| 6670 | } |
| 6671 | this.boy.emit( |
| 6672 | "field", |
| 6673 | decodeText(this._key, "binary", this.charset), |
| 6674 | decodeText(this._val, "binary", this.charset), |
| 6675 | this._keyTrunc, |
| 6676 | this._valTrunc |
| 6677 | ); |
| 6678 | this._state = "key"; |
| 6679 | this._hitLimit = false; |
| 6680 | this._checkingBytes = true; |
| 6681 | this._key = ""; |
| 6682 | this._bytesKey = 0; |
| 6683 | this._keyTrunc = false; |
| 6684 | this.decoder.reset(); |
| 6685 | p = idxamp + 1; |
| 6686 | if (this._fields === this.fieldsLimit) { |
| 6687 | return cb(); |
| 6688 | } |
| 6689 | } else if (this._hitLimit) { |
| 6690 | if (i > p) { |
| 6691 | this._val += this.decoder.write(data.toString("binary", p, i)); |
| 6692 | } |
| 6693 | p = i; |
| 6694 | if (this._val === "" && this.fieldSizeLimit === 0 || (this._bytesVal = this._val.length) === this.fieldSizeLimit) { |
| 6695 | this._checkingBytes = false; |
| 6696 | this._valTrunc = true; |
| 6697 | } |
| 6698 | } else { |
| 6699 | if (p < len) { |
| 6700 | this._val += this.decoder.write(data.toString("binary", p)); |
| 6701 | } |
| 6702 | p = len; |
| 6703 | } |
| 6704 | } |
| 6705 | } |
| 6706 | cb(); |
| 6707 | }; |
| 6708 | UrlEncoded.prototype.end = function() { |
| 6709 | if (this.boy._done) { |
| 6710 | return; |
| 6711 | } |
| 6712 | if (this._state === "key" && this._key.length > 0) { |
| 6713 | this.boy.emit( |
| 6714 | "field", |
| 6715 | decodeText(this._key, "binary", this.charset), |
| 6716 | "", |
| 6717 | this._keyTrunc, |
| 6718 | false |
| 6719 | ); |
| 6720 | } else if (this._state === "val") { |
| 6721 | this.boy.emit( |
| 6722 | "field", |
| 6723 | decodeText(this._key, "binary", this.charset), |
| 6724 | decodeText(this._val, "binary", this.charset), |
| 6725 | this._keyTrunc, |
| 6726 | this._valTrunc |
| 6727 | ); |
| 6728 | } |
| 6729 | this.boy._done = true; |
| 6730 | this.boy.emit("finish"); |
| 6731 | }; |
| 6732 | module2.exports = UrlEncoded; |
| 6733 | } |
| 6734 | }); |
| 6735 | |
| 6736 | // node_modules/.pnpm/@fastify+busboy@2.1.1/node_modules/@fastify/busboy/lib/main.js |
| 6737 | var require_main = __commonJS({ |
| 6738 | "node_modules/.pnpm/@fastify+busboy@2.1.1/node_modules/@fastify/busboy/lib/main.js"(exports2, module2) { |
| 6739 | "use strict"; |
| 6740 | var WritableStream = require("node:stream").Writable; |
| 6741 | var { inherits } = require("node:util"); |
| 6742 | var Dicer = require_Dicer(); |
| 6743 | var MultipartParser = require_multipart(); |
| 6744 | var UrlencodedParser = require_urlencoded(); |
| 6745 | var parseParams = require_parseParams(); |
| 6746 | function Busboy(opts) { |
| 6747 | if (!(this instanceof Busboy)) { |
| 6748 | return new Busboy(opts); |
| 6749 | } |
| 6750 | if (typeof opts !== "object") { |
| 6751 | throw new TypeError("Busboy expected an options-Object."); |
| 6752 | } |
| 6753 | if (typeof opts.headers !== "object") { |
| 6754 | throw new TypeError("Busboy expected an options-Object with headers-attribute."); |
| 6755 | } |
| 6756 | if (typeof opts.headers["content-type"] !== "string") { |
| 6757 | throw new TypeError("Missing Content-Type-header."); |
| 6758 | } |
| 6759 | const { |
| 6760 | headers, |
| 6761 | ...streamOptions |
| 6762 | } = opts; |
| 6763 | this.opts = { |
| 6764 | autoDestroy: false, |
| 6765 | ...streamOptions |
| 6766 | }; |
| 6767 | WritableStream.call(this, this.opts); |
| 6768 | this._done = false; |
| 6769 | this._parser = this.getParserByHeaders(headers); |
| 6770 | this._finished = false; |
| 6771 | } |
| 6772 | inherits(Busboy, WritableStream); |
| 6773 | Busboy.prototype.emit = function(ev) { |
| 6774 | if (ev === "finish") { |
| 6775 | if (!this._done) { |
| 6776 | this._parser?.end(); |
| 6777 | return; |
| 6778 | } else if (this._finished) { |
| 6779 | return; |
| 6780 | } |
| 6781 | this._finished = true; |
| 6782 | } |
| 6783 | WritableStream.prototype.emit.apply(this, arguments); |
| 6784 | }; |
| 6785 | Busboy.prototype.getParserByHeaders = function(headers) { |
| 6786 | const parsed = parseParams(headers["content-type"]); |
| 6787 | const cfg = { |
| 6788 | defCharset: this.opts.defCharset, |
| 6789 | fileHwm: this.opts.fileHwm, |
| 6790 | headers, |
| 6791 | highWaterMark: this.opts.highWaterMark, |
| 6792 | isPartAFile: this.opts.isPartAFile, |
| 6793 | limits: this.opts.limits, |
| 6794 | parsedConType: parsed, |
| 6795 | preservePath: this.opts.preservePath |
| 6796 | }; |
| 6797 | if (MultipartParser.detect.test(parsed[0])) { |
| 6798 | return new MultipartParser(this, cfg); |
| 6799 | } |
| 6800 | if (UrlencodedParser.detect.test(parsed[0])) { |
| 6801 | return new UrlencodedParser(this, cfg); |
| 6802 | } |
| 6803 | throw new Error("Unsupported Content-Type."); |
| 6804 | }; |
| 6805 | Busboy.prototype._write = function(chunk, encoding, cb) { |
| 6806 | this._parser.write(chunk, cb); |
| 6807 | }; |
| 6808 | module2.exports = Busboy; |
| 6809 | module2.exports.default = Busboy; |
| 6810 | module2.exports.Busboy = Busboy; |
| 6811 | module2.exports.Dicer = Dicer; |
| 6812 | } |
| 6813 | }); |
| 6814 | |
| 6815 | // node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/fetch/constants.js |
| 6816 | var require_constants2 = __commonJS({ |
| 6817 | "node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/fetch/constants.js"(exports2, module2) { |
| 6818 | "use strict"; |
| 6819 | var { MessageChannel, receiveMessageOnPort } = require("worker_threads"); |
| 6820 | var corsSafeListedMethods = ["GET", "HEAD", "POST"]; |
| 6821 | var corsSafeListedMethodsSet = new Set(corsSafeListedMethods); |
| 6822 | var nullBodyStatus = [101, 204, 205, 304]; |
| 6823 | var redirectStatus = [301, 302, 303, 307, 308]; |
| 6824 | var redirectStatusSet = new Set(redirectStatus); |
| 6825 | var badPorts = [ |
| 6826 | "1", |
| 6827 | "7", |
| 6828 | "9", |
| 6829 | "11", |
| 6830 | "13", |
| 6831 | "15", |
| 6832 | "17", |
| 6833 | "19", |
| 6834 | "20", |
| 6835 | "21", |
| 6836 | "22", |
| 6837 | "23", |
| 6838 | "25", |
| 6839 | "37", |
| 6840 | "42", |
| 6841 | "43", |
| 6842 | "53", |
| 6843 | "69", |
| 6844 | "77", |
| 6845 | "79", |
| 6846 | "87", |
| 6847 | "95", |
| 6848 | "101", |
| 6849 | "102", |
| 6850 | "103", |
| 6851 | "104", |
| 6852 | "109", |
| 6853 | "110", |
| 6854 | "111", |
| 6855 | "113", |
| 6856 | "115", |
| 6857 | "117", |
| 6858 | "119", |
| 6859 | "123", |
| 6860 | "135", |
| 6861 | "137", |
| 6862 | "139", |
| 6863 | "143", |
| 6864 | "161", |
| 6865 | "179", |
| 6866 | "389", |
| 6867 | "427", |
| 6868 | "465", |
| 6869 | "512", |
| 6870 | "513", |
| 6871 | "514", |
| 6872 | "515", |
| 6873 | "526", |
| 6874 | "530", |
| 6875 | "531", |
| 6876 | "532", |
| 6877 | "540", |
| 6878 | "548", |
| 6879 | "554", |
| 6880 | "556", |
| 6881 | "563", |
| 6882 | "587", |
| 6883 | "601", |
| 6884 | "636", |
| 6885 | "989", |
| 6886 | "990", |
| 6887 | "993", |
| 6888 | "995", |
| 6889 | "1719", |
| 6890 | "1720", |
| 6891 | "1723", |
| 6892 | "2049", |
| 6893 | "3659", |
| 6894 | "4045", |
| 6895 | "5060", |
| 6896 | "5061", |
| 6897 | "6000", |
| 6898 | "6566", |
| 6899 | "6665", |
| 6900 | "6666", |
| 6901 | "6667", |
| 6902 | "6668", |
| 6903 | "6669", |
| 6904 | "6697", |
| 6905 | "10080" |
| 6906 | ]; |
| 6907 | var badPortsSet = new Set(badPorts); |
| 6908 | var referrerPolicy = [ |
| 6909 | "", |
| 6910 | "no-referrer", |
| 6911 | "no-referrer-when-downgrade", |
| 6912 | "same-origin", |
| 6913 | "origin", |
| 6914 | "strict-origin", |
| 6915 | "origin-when-cross-origin", |
| 6916 | "strict-origin-when-cross-origin", |
| 6917 | "unsafe-url" |
| 6918 | ]; |
| 6919 | var referrerPolicySet = new Set(referrerPolicy); |
| 6920 | var requestRedirect = ["follow", "manual", "error"]; |
| 6921 | var safeMethods = ["GET", "HEAD", "OPTIONS", "TRACE"]; |
| 6922 | var safeMethodsSet = new Set(safeMethods); |
| 6923 | var requestMode = ["navigate", "same-origin", "no-cors", "cors"]; |
| 6924 | var requestCredentials = ["omit", "same-origin", "include"]; |
| 6925 | var requestCache = [ |
| 6926 | "default", |
| 6927 | "no-store", |
| 6928 | "reload", |
| 6929 | "no-cache", |
| 6930 | "force-cache", |
| 6931 | "only-if-cached" |
| 6932 | ]; |
| 6933 | var requestBodyHeader = [ |
| 6934 | "content-encoding", |
| 6935 | "content-language", |
| 6936 | "content-location", |
| 6937 | "content-type", |
| 6938 | // See https://github.com/nodejs/undici/issues/2021 |
| 6939 | // 'Content-Length' is a forbidden header name, which is typically |
| 6940 | // removed in the Headers implementation. However, undici doesn't |
| 6941 | // filter out headers, so we add it here. |
| 6942 | "content-length" |
| 6943 | ]; |
| 6944 | var requestDuplex = [ |
| 6945 | "half" |
| 6946 | ]; |
| 6947 | var forbiddenMethods = ["CONNECT", "TRACE", "TRACK"]; |
| 6948 | var forbiddenMethodsSet = new Set(forbiddenMethods); |
| 6949 | var subresource = [ |
| 6950 | "audio", |
| 6951 | "audioworklet", |
| 6952 | "font", |
| 6953 | "image", |
| 6954 | "manifest", |
| 6955 | "paintworklet", |
| 6956 | "script", |
| 6957 | "style", |
| 6958 | "track", |
| 6959 | "video", |
| 6960 | "xslt", |
| 6961 | "" |
| 6962 | ]; |
| 6963 | var subresourceSet = new Set(subresource); |
| 6964 | var DOMException2 = globalThis.DOMException ?? (() => { |
| 6965 | try { |
| 6966 | atob("~"); |
| 6967 | } catch (err) { |
| 6968 | return Object.getPrototypeOf(err).constructor; |
| 6969 | } |
| 6970 | })(); |
| 6971 | var channel; |
| 6972 | var structuredClone = globalThis.structuredClone ?? // https://github.com/nodejs/node/blob/b27ae24dcc4251bad726d9d84baf678d1f707fed/lib/internal/structured_clone.js |
| 6973 | // structuredClone was added in v17.0.0, but fetch supports v16.8 |
| 6974 | function structuredClone2(value, options = void 0) { |
| 6975 | if (arguments.length === 0) { |
| 6976 | throw new TypeError("missing argument"); |
| 6977 | } |
| 6978 | if (!channel) { |
| 6979 | channel = new MessageChannel(); |
| 6980 | } |
| 6981 | channel.port1.unref(); |
| 6982 | channel.port2.unref(); |
| 6983 | channel.port1.postMessage(value, options?.transfer); |
| 6984 | return receiveMessageOnPort(channel.port2).message; |
| 6985 | }; |
| 6986 | module2.exports = { |
| 6987 | DOMException: DOMException2, |
| 6988 | structuredClone, |
| 6989 | subresource, |
| 6990 | forbiddenMethods, |
| 6991 | requestBodyHeader, |
| 6992 | referrerPolicy, |
| 6993 | requestRedirect, |
| 6994 | requestMode, |
| 6995 | requestCredentials, |
| 6996 | requestCache, |
| 6997 | redirectStatus, |
| 6998 | corsSafeListedMethods, |
| 6999 | nullBodyStatus, |
| 7000 | safeMethods, |
| 7001 | badPorts, |
| 7002 | requestDuplex, |
| 7003 | subresourceSet, |
| 7004 | badPortsSet, |
| 7005 | redirectStatusSet, |
| 7006 | corsSafeListedMethodsSet, |
| 7007 | safeMethodsSet, |
| 7008 | forbiddenMethodsSet, |
| 7009 | referrerPolicySet |
| 7010 | }; |
| 7011 | } |
| 7012 | }); |
| 7013 | |
| 7014 | // node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/fetch/global.js |
| 7015 | var require_global = __commonJS({ |
| 7016 | "node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/fetch/global.js"(exports2, module2) { |
| 7017 | "use strict"; |
| 7018 | var globalOrigin = Symbol.for("undici.globalOrigin.1"); |
| 7019 | function getGlobalOrigin() { |
| 7020 | return globalThis[globalOrigin]; |
| 7021 | } |
| 7022 | function setGlobalOrigin(newOrigin) { |
| 7023 | if (newOrigin === void 0) { |
| 7024 | Object.defineProperty(globalThis, globalOrigin, { |
| 7025 | value: void 0, |
| 7026 | writable: true, |
| 7027 | enumerable: false, |
| 7028 | configurable: false |
| 7029 | }); |
| 7030 | return; |
| 7031 | } |
| 7032 | const parsedURL = new URL(newOrigin); |
| 7033 | if (parsedURL.protocol !== "http:" && parsedURL.protocol !== "https:") { |
| 7034 | throw new TypeError(`Only http & https urls are allowed, received ${parsedURL.protocol}`); |
| 7035 | } |
| 7036 | Object.defineProperty(globalThis, globalOrigin, { |
| 7037 | value: parsedURL, |
| 7038 | writable: true, |
| 7039 | enumerable: false, |
| 7040 | configurable: false |
| 7041 | }); |
| 7042 | } |
| 7043 | module2.exports = { |
| 7044 | getGlobalOrigin, |
| 7045 | setGlobalOrigin |
| 7046 | }; |
| 7047 | } |
| 7048 | }); |
| 7049 | |
| 7050 | // node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/fetch/util.js |
| 7051 | var require_util2 = __commonJS({ |
| 7052 | "node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/fetch/util.js"(exports2, module2) { |
| 7053 | "use strict"; |
| 7054 | var { redirectStatusSet, referrerPolicySet: referrerPolicyTokens, badPortsSet } = require_constants2(); |
| 7055 | var { getGlobalOrigin } = require_global(); |
| 7056 | var { performance: performance2 } = require("perf_hooks"); |
| 7057 | var { isBlobLike, toUSVString, ReadableStreamFrom } = require_util(); |
| 7058 | var assert = require("assert"); |
| 7059 | var { isUint8Array } = require("util/types"); |
| 7060 | var supportedHashes = []; |
| 7061 | var crypto; |
| 7062 | try { |
| 7063 | crypto = require("crypto"); |
| 7064 | const possibleRelevantHashes = ["sha256", "sha384", "sha512"]; |
| 7065 | supportedHashes = crypto.getHashes().filter((hash) => possibleRelevantHashes.includes(hash)); |
| 7066 | } catch { |
| 7067 | } |
| 7068 | function responseURL(response) { |
| 7069 | const urlList = response.urlList; |
| 7070 | const length = urlList.length; |
| 7071 | return length === 0 ? null : urlList[length - 1].toString(); |
| 7072 | } |
| 7073 | function responseLocationURL(response, requestFragment) { |
| 7074 | if (!redirectStatusSet.has(response.status)) { |
| 7075 | return null; |
| 7076 | } |
| 7077 | let location = response.headersList.get("location"); |
| 7078 | if (location !== null && isValidHeaderValue(location)) { |
| 7079 | location = new URL(location, responseURL(response)); |
| 7080 | } |
| 7081 | if (location && !location.hash) { |
| 7082 | location.hash = requestFragment; |
| 7083 | } |
| 7084 | return location; |
| 7085 | } |
| 7086 | function requestCurrentURL(request2) { |
| 7087 | return request2.urlList[request2.urlList.length - 1]; |
| 7088 | } |
| 7089 | function requestBadPort(request2) { |
| 7090 | const url = requestCurrentURL(request2); |
| 7091 | if (urlIsHttpHttpsScheme(url) && badPortsSet.has(url.port)) { |
| 7092 | return "blocked"; |
| 7093 | } |
| 7094 | return "allowed"; |
| 7095 | } |
| 7096 | function isErrorLike(object) { |
| 7097 | return object instanceof Error || (object?.constructor?.name === "Error" || object?.constructor?.name === "DOMException"); |
| 7098 | } |
| 7099 | function isValidReasonPhrase(statusText) { |
| 7100 | for (let i = 0; i < statusText.length; ++i) { |
| 7101 | const c = statusText.charCodeAt(i); |
| 7102 | if (!(c === 9 || // HTAB |
| 7103 | c >= 32 && c <= 126 || // SP / VCHAR |
| 7104 | c >= 128 && c <= 255)) { |
| 7105 | return false; |
| 7106 | } |
| 7107 | } |
| 7108 | return true; |
| 7109 | } |
| 7110 | function isTokenCharCode(c) { |
| 7111 | switch (c) { |
| 7112 | case 34: |
| 7113 | case 40: |
| 7114 | case 41: |
| 7115 | case 44: |
| 7116 | case 47: |
| 7117 | case 58: |
| 7118 | case 59: |
| 7119 | case 60: |
| 7120 | case 61: |
| 7121 | case 62: |
| 7122 | case 63: |
| 7123 | case 64: |
| 7124 | case 91: |
| 7125 | case 92: |
| 7126 | case 93: |
| 7127 | case 123: |
| 7128 | case 125: |
| 7129 | return false; |
| 7130 | default: |
| 7131 | return c >= 33 && c <= 126; |
| 7132 | } |
| 7133 | } |
| 7134 | function isValidHTTPToken(characters) { |
| 7135 | if (characters.length === 0) { |
| 7136 | return false; |
| 7137 | } |
| 7138 | for (let i = 0; i < characters.length; ++i) { |
| 7139 | if (!isTokenCharCode(characters.charCodeAt(i))) { |
| 7140 | return false; |
| 7141 | } |
| 7142 | } |
| 7143 | return true; |
| 7144 | } |
| 7145 | function isValidHeaderName(potentialValue) { |
| 7146 | return isValidHTTPToken(potentialValue); |
| 7147 | } |
| 7148 | function isValidHeaderValue(potentialValue) { |
| 7149 | if (potentialValue.startsWith(" ") || potentialValue.startsWith(" ") || potentialValue.endsWith(" ") || potentialValue.endsWith(" ")) { |
| 7150 | return false; |
| 7151 | } |
| 7152 | if (potentialValue.includes("\0") || potentialValue.includes("\r") || potentialValue.includes("\n")) { |
| 7153 | return false; |
| 7154 | } |
| 7155 | return true; |
| 7156 | } |
| 7157 | function setRequestReferrerPolicyOnRedirect(request2, actualResponse) { |
| 7158 | const { headersList } = actualResponse; |
| 7159 | const policyHeader = (headersList.get("referrer-policy") ?? "").split(","); |
| 7160 | let policy = ""; |
| 7161 | if (policyHeader.length > 0) { |
| 7162 | for (let i = policyHeader.length; i !== 0; i--) { |
| 7163 | const token = policyHeader[i - 1].trim(); |
| 7164 | if (referrerPolicyTokens.has(token)) { |
| 7165 | policy = token; |
| 7166 | break; |
| 7167 | } |
| 7168 | } |
| 7169 | } |
| 7170 | if (policy !== "") { |
| 7171 | request2.referrerPolicy = policy; |
| 7172 | } |
| 7173 | } |
| 7174 | function crossOriginResourcePolicyCheck() { |
| 7175 | return "allowed"; |
| 7176 | } |
| 7177 | function corsCheck() { |
| 7178 | return "success"; |
| 7179 | } |
| 7180 | function TAOCheck() { |
| 7181 | return "success"; |
| 7182 | } |
| 7183 | function appendFetchMetadata(httpRequest) { |
| 7184 | let header = null; |
| 7185 | header = httpRequest.mode; |
| 7186 | httpRequest.headersList.set("sec-fetch-mode", header); |
| 7187 | } |
| 7188 | function appendRequestOriginHeader(request2) { |
| 7189 | let serializedOrigin = request2.origin; |
| 7190 | if (request2.responseTainting === "cors" || request2.mode === "websocket") { |
| 7191 | if (serializedOrigin) { |
| 7192 | request2.headersList.append("origin", serializedOrigin); |
| 7193 | } |
| 7194 | } else if (request2.method !== "GET" && request2.method !== "HEAD") { |
| 7195 | switch (request2.referrerPolicy) { |
| 7196 | case "no-referrer": |
| 7197 | serializedOrigin = null; |
| 7198 | break; |
| 7199 | case "no-referrer-when-downgrade": |
| 7200 | case "strict-origin": |
| 7201 | case "strict-origin-when-cross-origin": |
| 7202 | if (request2.origin && urlHasHttpsScheme(request2.origin) && !urlHasHttpsScheme(requestCurrentURL(request2))) { |
| 7203 | serializedOrigin = null; |
| 7204 | } |
| 7205 | break; |
| 7206 | case "same-origin": |
| 7207 | if (!sameOrigin(request2, requestCurrentURL(request2))) { |
| 7208 | serializedOrigin = null; |
| 7209 | } |
| 7210 | break; |
| 7211 | default: |
| 7212 | } |
| 7213 | if (serializedOrigin) { |
| 7214 | request2.headersList.append("origin", serializedOrigin); |
| 7215 | } |
| 7216 | } |
| 7217 | } |
| 7218 | function coarsenedSharedCurrentTime(crossOriginIsolatedCapability) { |
| 7219 | return performance2.now(); |
| 7220 | } |
| 7221 | function createOpaqueTimingInfo(timingInfo) { |
| 7222 | return { |
| 7223 | startTime: timingInfo.startTime ?? 0, |
| 7224 | redirectStartTime: 0, |
| 7225 | redirectEndTime: 0, |
| 7226 | postRedirectStartTime: timingInfo.startTime ?? 0, |
| 7227 | finalServiceWorkerStartTime: 0, |
| 7228 | finalNetworkResponseStartTime: 0, |
| 7229 | finalNetworkRequestStartTime: 0, |
| 7230 | endTime: 0, |
| 7231 | encodedBodySize: 0, |
| 7232 | decodedBodySize: 0, |
| 7233 | finalConnectionTimingInfo: null |
| 7234 | }; |
| 7235 | } |
| 7236 | function makePolicyContainer() { |
| 7237 | return { |
| 7238 | referrerPolicy: "strict-origin-when-cross-origin" |
| 7239 | }; |
| 7240 | } |
| 7241 | function clonePolicyContainer(policyContainer) { |
| 7242 | return { |
| 7243 | referrerPolicy: policyContainer.referrerPolicy |
| 7244 | }; |
| 7245 | } |
| 7246 | function determineRequestsReferrer(request2) { |
| 7247 | const policy = request2.referrerPolicy; |
| 7248 | assert(policy); |
| 7249 | let referrerSource = null; |
| 7250 | if (request2.referrer === "client") { |
| 7251 | const globalOrigin = getGlobalOrigin(); |
| 7252 | if (!globalOrigin || globalOrigin.origin === "null") { |
| 7253 | return "no-referrer"; |
| 7254 | } |
| 7255 | referrerSource = new URL(globalOrigin); |
| 7256 | } else if (request2.referrer instanceof URL) { |
| 7257 | referrerSource = request2.referrer; |
| 7258 | } |
| 7259 | let referrerURL = stripURLForReferrer(referrerSource); |
| 7260 | const referrerOrigin = stripURLForReferrer(referrerSource, true); |
| 7261 | if (referrerURL.toString().length > 4096) { |
| 7262 | referrerURL = referrerOrigin; |
| 7263 | } |
| 7264 | const areSameOrigin = sameOrigin(request2, referrerURL); |
| 7265 | const isNonPotentiallyTrustWorthy = isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(request2.url); |
| 7266 | switch (policy) { |
| 7267 | case "origin": |
| 7268 | return referrerOrigin != null ? referrerOrigin : stripURLForReferrer(referrerSource, true); |
| 7269 | case "unsafe-url": |
| 7270 | return referrerURL; |
| 7271 | case "same-origin": |
| 7272 | return areSameOrigin ? referrerOrigin : "no-referrer"; |
| 7273 | case "origin-when-cross-origin": |
| 7274 | return areSameOrigin ? referrerURL : referrerOrigin; |
| 7275 | case "strict-origin-when-cross-origin": { |
| 7276 | const currentURL = requestCurrentURL(request2); |
| 7277 | if (sameOrigin(referrerURL, currentURL)) { |
| 7278 | return referrerURL; |
| 7279 | } |
| 7280 | if (isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(currentURL)) { |
| 7281 | return "no-referrer"; |
| 7282 | } |
| 7283 | return referrerOrigin; |
| 7284 | } |
| 7285 | case "strict-origin": |
| 7286 | case "no-referrer-when-downgrade": |
| 7287 | default: |
| 7288 | return isNonPotentiallyTrustWorthy ? "no-referrer" : referrerOrigin; |
| 7289 | } |
| 7290 | } |
| 7291 | function stripURLForReferrer(url, originOnly) { |
| 7292 | assert(url instanceof URL); |
| 7293 | if (url.protocol === "file:" || url.protocol === "about:" || url.protocol === "blank:") { |
| 7294 | return "no-referrer"; |
| 7295 | } |
| 7296 | url.username = ""; |
| 7297 | url.password = ""; |
| 7298 | url.hash = ""; |
| 7299 | if (originOnly) { |
| 7300 | url.pathname = ""; |
| 7301 | url.search = ""; |
| 7302 | } |
| 7303 | return url; |
| 7304 | } |
| 7305 | function isURLPotentiallyTrustworthy(url) { |
| 7306 | if (!(url instanceof URL)) { |
| 7307 | return false; |
| 7308 | } |
| 7309 | if (url.href === "about:blank" || url.href === "about:srcdoc") { |
| 7310 | return true; |
| 7311 | } |
| 7312 | if (url.protocol === "data:") return true; |
| 7313 | if (url.protocol === "file:") return true; |
| 7314 | return isOriginPotentiallyTrustworthy(url.origin); |
| 7315 | function isOriginPotentiallyTrustworthy(origin) { |
| 7316 | if (origin == null || origin === "null") return false; |
| 7317 | const originAsURL = new URL(origin); |
| 7318 | if (originAsURL.protocol === "https:" || originAsURL.protocol === "wss:") { |
| 7319 | return true; |
| 7320 | } |
| 7321 | if (/^127(?:\.[0-9]+){0,2}\.[0-9]+$|^\[(?:0*:)*?:?0*1\]$/.test(originAsURL.hostname) || (originAsURL.hostname === "localhost" || originAsURL.hostname.includes("localhost.")) || originAsURL.hostname.endsWith(".localhost")) { |
| 7322 | return true; |
| 7323 | } |
| 7324 | return false; |
| 7325 | } |
| 7326 | } |
| 7327 | function bytesMatch(bytes, metadataList) { |
| 7328 | if (crypto === void 0) { |
| 7329 | return true; |
| 7330 | } |
| 7331 | const parsedMetadata = parseMetadata(metadataList); |
| 7332 | if (parsedMetadata === "no metadata") { |
| 7333 | return true; |
| 7334 | } |
| 7335 | if (parsedMetadata.length === 0) { |
| 7336 | return true; |
| 7337 | } |
| 7338 | const strongest = getStrongestMetadata(parsedMetadata); |
| 7339 | const metadata = filterMetadataListByAlgorithm(parsedMetadata, strongest); |
| 7340 | for (const item of metadata) { |
| 7341 | const algorithm = item.algo; |
| 7342 | const expectedValue = item.hash; |
| 7343 | let actualValue = crypto.createHash(algorithm).update(bytes).digest("base64"); |
| 7344 | if (actualValue[actualValue.length - 1] === "=") { |
| 7345 | if (actualValue[actualValue.length - 2] === "=") { |
| 7346 | actualValue = actualValue.slice(0, -2); |
| 7347 | } else { |
| 7348 | actualValue = actualValue.slice(0, -1); |
| 7349 | } |
| 7350 | } |
| 7351 | if (compareBase64Mixed(actualValue, expectedValue)) { |
| 7352 | return true; |
| 7353 | } |
| 7354 | } |
| 7355 | return false; |
| 7356 | } |
| 7357 | var parseHashWithOptions = /(?<algo>sha256|sha384|sha512)-((?<hash>[A-Za-z0-9+/]+|[A-Za-z0-9_-]+)={0,2}(?:\s|$)( +[!-~]*)?)?/i; |
| 7358 | function parseMetadata(metadata) { |
| 7359 | const result = []; |
| 7360 | let empty = true; |
| 7361 | for (const token of metadata.split(" ")) { |
| 7362 | empty = false; |
| 7363 | const parsedToken = parseHashWithOptions.exec(token); |
| 7364 | if (parsedToken === null || parsedToken.groups === void 0 || parsedToken.groups.algo === void 0) { |
| 7365 | continue; |
| 7366 | } |
| 7367 | const algorithm = parsedToken.groups.algo.toLowerCase(); |
| 7368 | if (supportedHashes.includes(algorithm)) { |
| 7369 | result.push(parsedToken.groups); |
| 7370 | } |
| 7371 | } |
| 7372 | if (empty === true) { |
| 7373 | return "no metadata"; |
| 7374 | } |
| 7375 | return result; |
| 7376 | } |
| 7377 | function getStrongestMetadata(metadataList) { |
| 7378 | let algorithm = metadataList[0].algo; |
| 7379 | if (algorithm[3] === "5") { |
| 7380 | return algorithm; |
| 7381 | } |
| 7382 | for (let i = 1; i < metadataList.length; ++i) { |
| 7383 | const metadata = metadataList[i]; |
| 7384 | if (metadata.algo[3] === "5") { |
| 7385 | algorithm = "sha512"; |
| 7386 | break; |
| 7387 | } else if (algorithm[3] === "3") { |
| 7388 | continue; |
| 7389 | } else if (metadata.algo[3] === "3") { |
| 7390 | algorithm = "sha384"; |
| 7391 | } |
| 7392 | } |
| 7393 | return algorithm; |
| 7394 | } |
| 7395 | function filterMetadataListByAlgorithm(metadataList, algorithm) { |
| 7396 | if (metadataList.length === 1) { |
| 7397 | return metadataList; |
| 7398 | } |
| 7399 | let pos = 0; |
| 7400 | for (let i = 0; i < metadataList.length; ++i) { |
| 7401 | if (metadataList[i].algo === algorithm) { |
| 7402 | metadataList[pos++] = metadataList[i]; |
| 7403 | } |
| 7404 | } |
| 7405 | metadataList.length = pos; |
| 7406 | return metadataList; |
| 7407 | } |
| 7408 | function compareBase64Mixed(actualValue, expectedValue) { |
| 7409 | if (actualValue.length !== expectedValue.length) { |
| 7410 | return false; |
| 7411 | } |
| 7412 | for (let i = 0; i < actualValue.length; ++i) { |
| 7413 | if (actualValue[i] !== expectedValue[i]) { |
| 7414 | if (actualValue[i] === "+" && expectedValue[i] === "-" || actualValue[i] === "/" && expectedValue[i] === "_") { |
| 7415 | continue; |
| 7416 | } |
| 7417 | return false; |
| 7418 | } |
| 7419 | } |
| 7420 | return true; |
| 7421 | } |
| 7422 | function tryUpgradeRequestToAPotentiallyTrustworthyURL(request2) { |
| 7423 | } |
| 7424 | function sameOrigin(A, B) { |
| 7425 | if (A.origin === B.origin && A.origin === "null") { |
| 7426 | return true; |
| 7427 | } |
| 7428 | if (A.protocol === B.protocol && A.hostname === B.hostname && A.port === B.port) { |
| 7429 | return true; |
| 7430 | } |
| 7431 | return false; |
| 7432 | } |
| 7433 | function createDeferredPromise() { |
| 7434 | let res; |
| 7435 | let rej; |
| 7436 | const promise = new Promise((resolve, reject) => { |
| 7437 | res = resolve; |
| 7438 | rej = reject; |
| 7439 | }); |
| 7440 | return { promise, resolve: res, reject: rej }; |
| 7441 | } |
| 7442 | function isAborted(fetchParams) { |
| 7443 | return fetchParams.controller.state === "aborted"; |
| 7444 | } |
| 7445 | function isCancelled(fetchParams) { |
| 7446 | return fetchParams.controller.state === "aborted" || fetchParams.controller.state === "terminated"; |
| 7447 | } |
| 7448 | var normalizeMethodRecord = { |
| 7449 | delete: "DELETE", |
| 7450 | DELETE: "DELETE", |
| 7451 | get: "GET", |
| 7452 | GET: "GET", |
| 7453 | head: "HEAD", |
| 7454 | HEAD: "HEAD", |
| 7455 | options: "OPTIONS", |
| 7456 | OPTIONS: "OPTIONS", |
| 7457 | post: "POST", |
| 7458 | POST: "POST", |
| 7459 | put: "PUT", |
| 7460 | PUT: "PUT" |
| 7461 | }; |
| 7462 | Object.setPrototypeOf(normalizeMethodRecord, null); |
| 7463 | function normalizeMethod(method) { |
| 7464 | return normalizeMethodRecord[method.toLowerCase()] ?? method; |
| 7465 | } |
| 7466 | function serializeJavascriptValueToJSONString(value) { |
| 7467 | const result = JSON.stringify(value); |
| 7468 | if (result === void 0) { |
| 7469 | throw new TypeError("Value is not JSON serializable"); |
| 7470 | } |
| 7471 | assert(typeof result === "string"); |
| 7472 | return result; |
| 7473 | } |
| 7474 | var esIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]())); |
| 7475 | function makeIterator(iterator2, name, kind) { |
| 7476 | const object = { |
| 7477 | index: 0, |
| 7478 | kind, |
| 7479 | target: iterator2 |
| 7480 | }; |
| 7481 | const i = { |
| 7482 | next() { |
| 7483 | if (Object.getPrototypeOf(this) !== i) { |
| 7484 | throw new TypeError( |
| 7485 | `'next' called on an object that does not implement interface ${name} Iterator.` |
| 7486 | ); |
| 7487 | } |
| 7488 | const { index, kind: kind2, target } = object; |
| 7489 | const values = target(); |
| 7490 | const len = values.length; |
| 7491 | if (index >= len) { |
| 7492 | return { value: void 0, done: true }; |
| 7493 | } |
| 7494 | const pair = values[index]; |
| 7495 | object.index = index + 1; |
| 7496 | return iteratorResult(pair, kind2); |
| 7497 | }, |
| 7498 | // The class string of an iterator prototype object for a given interface is the |
| 7499 | // result of concatenating the identifier of the interface and the string " Iterator". |
| 7500 | [Symbol.toStringTag]: `${name} Iterator` |
| 7501 | }; |
| 7502 | Object.setPrototypeOf(i, esIteratorPrototype); |
| 7503 | return Object.setPrototypeOf({}, i); |
| 7504 | } |
| 7505 | function iteratorResult(pair, kind) { |
| 7506 | let result; |
| 7507 | switch (kind) { |
| 7508 | case "key": { |
| 7509 | result = pair[0]; |
| 7510 | break; |
| 7511 | } |
| 7512 | case "value": { |
| 7513 | result = pair[1]; |
| 7514 | break; |
| 7515 | } |
| 7516 | case "key+value": { |
| 7517 | result = pair; |
| 7518 | break; |
| 7519 | } |
| 7520 | } |
| 7521 | return { value: result, done: false }; |
| 7522 | } |
| 7523 | async function fullyReadBody(body, processBody, processBodyError) { |
| 7524 | const successSteps = processBody; |
| 7525 | const errorSteps = processBodyError; |
| 7526 | let reader; |
| 7527 | try { |
| 7528 | reader = body.stream.getReader(); |
| 7529 | } catch (e) { |
| 7530 | errorSteps(e); |
| 7531 | return; |
| 7532 | } |
| 7533 | try { |
| 7534 | const result = await readAllBytes(reader); |
| 7535 | successSteps(result); |
| 7536 | } catch (e) { |
| 7537 | errorSteps(e); |
| 7538 | } |
| 7539 | } |
| 7540 | var ReadableStream = globalThis.ReadableStream; |
| 7541 | function isReadableStreamLike(stream) { |
| 7542 | if (!ReadableStream) { |
| 7543 | ReadableStream = require("stream/web").ReadableStream; |
| 7544 | } |
| 7545 | return stream instanceof ReadableStream || stream[Symbol.toStringTag] === "ReadableStream" && typeof stream.tee === "function"; |
| 7546 | } |
| 7547 | var MAXIMUM_ARGUMENT_LENGTH = 65535; |
| 7548 | function isomorphicDecode(input) { |
| 7549 | if (input.length < MAXIMUM_ARGUMENT_LENGTH) { |
| 7550 | return String.fromCharCode(...input); |
| 7551 | } |
| 7552 | return input.reduce((previous, current) => previous + String.fromCharCode(current), ""); |
| 7553 | } |
| 7554 | function readableStreamClose(controller) { |
| 7555 | try { |
| 7556 | controller.close(); |
| 7557 | } catch (err) { |
| 7558 | if (!err.message.includes("Controller is already closed")) { |
| 7559 | throw err; |
| 7560 | } |
| 7561 | } |
| 7562 | } |
| 7563 | function isomorphicEncode(input) { |
| 7564 | for (let i = 0; i < input.length; i++) { |
| 7565 | assert(input.charCodeAt(i) <= 255); |
| 7566 | } |
| 7567 | return input; |
| 7568 | } |
| 7569 | async function readAllBytes(reader) { |
| 7570 | const bytes = []; |
| 7571 | let byteLength = 0; |
| 7572 | while (true) { |
| 7573 | const { done, value: chunk } = await reader.read(); |
| 7574 | if (done) { |
| 7575 | return Buffer.concat(bytes, byteLength); |
| 7576 | } |
| 7577 | if (!isUint8Array(chunk)) { |
| 7578 | throw new TypeError("Received non-Uint8Array chunk"); |
| 7579 | } |
| 7580 | bytes.push(chunk); |
| 7581 | byteLength += chunk.length; |
| 7582 | } |
| 7583 | } |
| 7584 | function urlIsLocal(url) { |
| 7585 | assert("protocol" in url); |
| 7586 | const protocol = url.protocol; |
| 7587 | return protocol === "about:" || protocol === "blob:" || protocol === "data:"; |
| 7588 | } |
| 7589 | function urlHasHttpsScheme(url) { |
| 7590 | if (typeof url === "string") { |
| 7591 | return url.startsWith("https:"); |
| 7592 | } |
| 7593 | return url.protocol === "https:"; |
| 7594 | } |
| 7595 | function urlIsHttpHttpsScheme(url) { |
| 7596 | assert("protocol" in url); |
| 7597 | const protocol = url.protocol; |
| 7598 | return protocol === "http:" || protocol === "https:"; |
| 7599 | } |
| 7600 | var hasOwn = Object.hasOwn || ((dict, key) => Object.prototype.hasOwnProperty.call(dict, key)); |
| 7601 | module2.exports = { |
| 7602 | isAborted, |
| 7603 | isCancelled, |
| 7604 | createDeferredPromise, |
| 7605 | ReadableStreamFrom, |
| 7606 | toUSVString, |
| 7607 | tryUpgradeRequestToAPotentiallyTrustworthyURL, |
| 7608 | coarsenedSharedCurrentTime, |
| 7609 | determineRequestsReferrer, |
| 7610 | makePolicyContainer, |
| 7611 | clonePolicyContainer, |
| 7612 | appendFetchMetadata, |
| 7613 | appendRequestOriginHeader, |
| 7614 | TAOCheck, |
| 7615 | corsCheck, |
| 7616 | crossOriginResourcePolicyCheck, |
| 7617 | createOpaqueTimingInfo, |
| 7618 | setRequestReferrerPolicyOnRedirect, |
| 7619 | isValidHTTPToken, |
| 7620 | requestBadPort, |
| 7621 | requestCurrentURL, |
| 7622 | responseURL, |
| 7623 | responseLocationURL, |
| 7624 | isBlobLike, |
| 7625 | isURLPotentiallyTrustworthy, |
| 7626 | isValidReasonPhrase, |
| 7627 | sameOrigin, |
| 7628 | normalizeMethod, |
| 7629 | serializeJavascriptValueToJSONString, |
| 7630 | makeIterator, |
| 7631 | isValidHeaderName, |
| 7632 | isValidHeaderValue, |
| 7633 | hasOwn, |
| 7634 | isErrorLike, |
| 7635 | fullyReadBody, |
| 7636 | bytesMatch, |
| 7637 | isReadableStreamLike, |
| 7638 | readableStreamClose, |
| 7639 | isomorphicEncode, |
| 7640 | isomorphicDecode, |
| 7641 | urlIsLocal, |
| 7642 | urlHasHttpsScheme, |
| 7643 | urlIsHttpHttpsScheme, |
| 7644 | readAllBytes, |
| 7645 | normalizeMethodRecord, |
| 7646 | parseMetadata |
| 7647 | }; |
| 7648 | } |
| 7649 | }); |
| 7650 | |
| 7651 | // node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/fetch/symbols.js |
| 7652 | var require_symbols2 = __commonJS({ |
| 7653 | "node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/fetch/symbols.js"(exports2, module2) { |
| 7654 | "use strict"; |
| 7655 | module2.exports = { |
| 7656 | kUrl: Symbol("url"), |
| 7657 | kHeaders: Symbol("headers"), |
| 7658 | kSignal: Symbol("signal"), |
| 7659 | kState: Symbol("state"), |
| 7660 | kGuard: Symbol("guard"), |
| 7661 | kRealm: Symbol("realm") |
| 7662 | }; |
| 7663 | } |
| 7664 | }); |
| 7665 | |
| 7666 | // node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/fetch/webidl.js |
| 7667 | var require_webidl = __commonJS({ |
| 7668 | "node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/fetch/webidl.js"(exports2, module2) { |
| 7669 | "use strict"; |
| 7670 | var { types } = require("util"); |
| 7671 | var { hasOwn, toUSVString } = require_util2(); |
| 7672 | var webidl = {}; |
| 7673 | webidl.converters = {}; |
| 7674 | webidl.util = {}; |
| 7675 | webidl.errors = {}; |
| 7676 | webidl.errors.exception = function(message) { |
| 7677 | return new TypeError(`${message.header}: ${message.message}`); |
| 7678 | }; |
| 7679 | webidl.errors.conversionFailed = function(context) { |
| 7680 | const plural = context.types.length === 1 ? "" : " one of"; |
| 7681 | const message = `${context.argument} could not be converted to${plural}: ${context.types.join(", ")}.`; |
| 7682 | return webidl.errors.exception({ |
| 7683 | header: context.prefix, |
| 7684 | message |
| 7685 | }); |
| 7686 | }; |
| 7687 | webidl.errors.invalidArgument = function(context) { |
| 7688 | return webidl.errors.exception({ |
| 7689 | header: context.prefix, |
| 7690 | message: `"${context.value}" is an invalid ${context.type}.` |
| 7691 | }); |
| 7692 | }; |
| 7693 | webidl.brandCheck = function(V, I, opts = void 0) { |
| 7694 | if (opts?.strict !== false && !(V instanceof I)) { |
| 7695 | throw new TypeError("Illegal invocation"); |
| 7696 | } else { |
| 7697 | return V?.[Symbol.toStringTag] === I.prototype[Symbol.toStringTag]; |
| 7698 | } |
| 7699 | }; |
| 7700 | webidl.argumentLengthCheck = function({ length }, min, ctx) { |
| 7701 | if (length < min) { |
| 7702 | throw webidl.errors.exception({ |
| 7703 | message: `${min} argument${min !== 1 ? "s" : ""} required, but${length ? " only" : ""} ${length} found.`, |
| 7704 | ...ctx |
| 7705 | }); |
| 7706 | } |
| 7707 | }; |
| 7708 | webidl.illegalConstructor = function() { |
| 7709 | throw webidl.errors.exception({ |
| 7710 | header: "TypeError", |
| 7711 | message: "Illegal constructor" |
| 7712 | }); |
| 7713 | }; |
| 7714 | webidl.util.Type = function(V) { |
| 7715 | switch (typeof V) { |
| 7716 | case "undefined": |
| 7717 | return "Undefined"; |
| 7718 | case "boolean": |
| 7719 | return "Boolean"; |
| 7720 | case "string": |
| 7721 | return "String"; |
| 7722 | case "symbol": |
| 7723 | return "Symbol"; |
| 7724 | case "number": |
| 7725 | return "Number"; |
| 7726 | case "bigint": |
| 7727 | return "BigInt"; |
| 7728 | case "function": |
| 7729 | case "object": { |
| 7730 | if (V === null) { |
| 7731 | return "Null"; |
| 7732 | } |
| 7733 | return "Object"; |
| 7734 | } |
| 7735 | } |
| 7736 | }; |
| 7737 | webidl.util.ConvertToInt = function(V, bitLength, signedness, opts = {}) { |
| 7738 | let upperBound; |
| 7739 | let lowerBound; |
| 7740 | if (bitLength === 64) { |
| 7741 | upperBound = Math.pow(2, 53) - 1; |
| 7742 | if (signedness === "unsigned") { |
| 7743 | lowerBound = 0; |
| 7744 | } else { |
| 7745 | lowerBound = Math.pow(-2, 53) + 1; |
| 7746 | } |
| 7747 | } else if (signedness === "unsigned") { |
| 7748 | lowerBound = 0; |
| 7749 | upperBound = Math.pow(2, bitLength) - 1; |
| 7750 | } else { |
| 7751 | lowerBound = Math.pow(-2, bitLength) - 1; |
| 7752 | upperBound = Math.pow(2, bitLength - 1) - 1; |
| 7753 | } |
| 7754 | let x = Number(V); |
| 7755 | if (x === 0) { |
| 7756 | x = 0; |
| 7757 | } |
| 7758 | if (opts.enforceRange === true) { |
| 7759 | if (Number.isNaN(x) || x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY) { |
| 7760 | throw webidl.errors.exception({ |
| 7761 | header: "Integer conversion", |
| 7762 | message: `Could not convert ${V} to an integer.` |
| 7763 | }); |
| 7764 | } |
| 7765 | x = webidl.util.IntegerPart(x); |
| 7766 | if (x < lowerBound || x > upperBound) { |
| 7767 | throw webidl.errors.exception({ |
| 7768 | header: "Integer conversion", |
| 7769 | message: `Value must be between ${lowerBound}-${upperBound}, got ${x}.` |
| 7770 | }); |
| 7771 | } |
| 7772 | return x; |
| 7773 | } |
| 7774 | if (!Number.isNaN(x) && opts.clamp === true) { |
| 7775 | x = Math.min(Math.max(x, lowerBound), upperBound); |
| 7776 | if (Math.floor(x) % 2 === 0) { |
| 7777 | x = Math.floor(x); |
| 7778 | } else { |
| 7779 | x = Math.ceil(x); |
| 7780 | } |
| 7781 | return x; |
| 7782 | } |
| 7783 | if (Number.isNaN(x) || x === 0 && Object.is(0, x) || x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY) { |
| 7784 | return 0; |
| 7785 | } |
| 7786 | x = webidl.util.IntegerPart(x); |
| 7787 | x = x % Math.pow(2, bitLength); |
| 7788 | if (signedness === "signed" && x >= Math.pow(2, bitLength) - 1) { |
| 7789 | return x - Math.pow(2, bitLength); |
| 7790 | } |
| 7791 | return x; |
| 7792 | }; |
| 7793 | webidl.util.IntegerPart = function(n) { |
| 7794 | const r = Math.floor(Math.abs(n)); |
| 7795 | if (n < 0) { |
| 7796 | return -1 * r; |
| 7797 | } |
| 7798 | return r; |
| 7799 | }; |
| 7800 | webidl.sequenceConverter = function(converter) { |
| 7801 | return (V) => { |
| 7802 | if (webidl.util.Type(V) !== "Object") { |
| 7803 | throw webidl.errors.exception({ |
| 7804 | header: "Sequence", |
| 7805 | message: `Value of type ${webidl.util.Type(V)} is not an Object.` |
| 7806 | }); |
| 7807 | } |
| 7808 | const method = V?.[Symbol.iterator]?.(); |
| 7809 | const seq = []; |
| 7810 | if (method === void 0 || typeof method.next !== "function") { |
| 7811 | throw webidl.errors.exception({ |
| 7812 | header: "Sequence", |
| 7813 | message: "Object is not an iterator." |
| 7814 | }); |
| 7815 | } |
| 7816 | while (true) { |
| 7817 | const { done, value } = method.next(); |
| 7818 | if (done) { |
| 7819 | break; |
| 7820 | } |
| 7821 | seq.push(converter(value)); |
| 7822 | } |
| 7823 | return seq; |
| 7824 | }; |
| 7825 | }; |
| 7826 | webidl.recordConverter = function(keyConverter, valueConverter) { |
| 7827 | return (O) => { |
| 7828 | if (webidl.util.Type(O) !== "Object") { |
| 7829 | throw webidl.errors.exception({ |
| 7830 | header: "Record", |
| 7831 | message: `Value of type ${webidl.util.Type(O)} is not an Object.` |
| 7832 | }); |
| 7833 | } |
| 7834 | const result = {}; |
| 7835 | if (!types.isProxy(O)) { |
| 7836 | const keys2 = Object.keys(O); |
| 7837 | for (const key of keys2) { |
| 7838 | const typedKey = keyConverter(key); |
| 7839 | const typedValue = valueConverter(O[key]); |
| 7840 | result[typedKey] = typedValue; |
| 7841 | } |
| 7842 | return result; |
| 7843 | } |
| 7844 | const keys = Reflect.ownKeys(O); |
| 7845 | for (const key of keys) { |
| 7846 | const desc = Reflect.getOwnPropertyDescriptor(O, key); |
| 7847 | if (desc?.enumerable) { |
| 7848 | const typedKey = keyConverter(key); |
| 7849 | const typedValue = valueConverter(O[key]); |
| 7850 | result[typedKey] = typedValue; |
| 7851 | } |
| 7852 | } |
| 7853 | return result; |
| 7854 | }; |
| 7855 | }; |
| 7856 | webidl.interfaceConverter = function(i) { |
| 7857 | return (V, opts = {}) => { |
| 7858 | if (opts.strict !== false && !(V instanceof i)) { |
| 7859 | throw webidl.errors.exception({ |
| 7860 | header: i.name, |
| 7861 | message: `Expected ${V} to be an instance of ${i.name}.` |
| 7862 | }); |
| 7863 | } |
| 7864 | return V; |
| 7865 | }; |
| 7866 | }; |
| 7867 | webidl.dictionaryConverter = function(converters) { |
| 7868 | return (dictionary) => { |
| 7869 | const type = webidl.util.Type(dictionary); |
| 7870 | const dict = {}; |
| 7871 | if (type === "Null" || type === "Undefined") { |
| 7872 | return dict; |
| 7873 | } else if (type !== "Object") { |
| 7874 | throw webidl.errors.exception({ |
| 7875 | header: "Dictionary", |
| 7876 | message: `Expected ${dictionary} to be one of: Null, Undefined, Object.` |
| 7877 | }); |
| 7878 | } |
| 7879 | for (const options of converters) { |
| 7880 | const { key, defaultValue, required, converter } = options; |
| 7881 | if (required === true) { |
| 7882 | if (!hasOwn(dictionary, key)) { |
| 7883 | throw webidl.errors.exception({ |
| 7884 | header: "Dictionary", |
| 7885 | message: `Missing required key "${key}".` |
| 7886 | }); |
| 7887 | } |
| 7888 | } |
| 7889 | let value = dictionary[key]; |
| 7890 | const hasDefault = hasOwn(options, "defaultValue"); |
| 7891 | if (hasDefault && value !== null) { |
| 7892 | value = value ?? defaultValue; |
| 7893 | } |
| 7894 | if (required || hasDefault || value !== void 0) { |
| 7895 | value = converter(value); |
| 7896 | if (options.allowedValues && !options.allowedValues.includes(value)) { |
| 7897 | throw webidl.errors.exception({ |
| 7898 | header: "Dictionary", |
| 7899 | message: `${value} is not an accepted type. Expected one of ${options.allowedValues.join(", ")}.` |
| 7900 | }); |
| 7901 | } |
| 7902 | dict[key] = value; |
| 7903 | } |
| 7904 | } |
| 7905 | return dict; |
| 7906 | }; |
| 7907 | }; |
| 7908 | webidl.nullableConverter = function(converter) { |
| 7909 | return (V) => { |
| 7910 | if (V === null) { |
| 7911 | return V; |
| 7912 | } |
| 7913 | return converter(V); |
| 7914 | }; |
| 7915 | }; |
| 7916 | webidl.converters.DOMString = function(V, opts = {}) { |
| 7917 | if (V === null && opts.legacyNullToEmptyString) { |
| 7918 | return ""; |
| 7919 | } |
| 7920 | if (typeof V === "symbol") { |
| 7921 | throw new TypeError("Could not convert argument of type symbol to string."); |
| 7922 | } |
| 7923 | return String(V); |
| 7924 | }; |
| 7925 | webidl.converters.ByteString = function(V) { |
| 7926 | const x = webidl.converters.DOMString(V); |
| 7927 | for (let index = 0; index < x.length; index++) { |
| 7928 | if (x.charCodeAt(index) > 255) { |
| 7929 | throw new TypeError( |
| 7930 | `Cannot convert argument to a ByteString because the character at index ${index} has a value of ${x.charCodeAt(index)} which is greater than 255.` |
| 7931 | ); |
| 7932 | } |
| 7933 | } |
| 7934 | return x; |
| 7935 | }; |
| 7936 | webidl.converters.USVString = toUSVString; |
| 7937 | webidl.converters.boolean = function(V) { |
| 7938 | const x = Boolean(V); |
| 7939 | return x; |
| 7940 | }; |
| 7941 | webidl.converters.any = function(V) { |
| 7942 | return V; |
| 7943 | }; |
| 7944 | webidl.converters["long long"] = function(V) { |
| 7945 | const x = webidl.util.ConvertToInt(V, 64, "signed"); |
| 7946 | return x; |
| 7947 | }; |
| 7948 | webidl.converters["unsigned long long"] = function(V) { |
| 7949 | const x = webidl.util.ConvertToInt(V, 64, "unsigned"); |
| 7950 | return x; |
| 7951 | }; |
| 7952 | webidl.converters["unsigned long"] = function(V) { |
| 7953 | const x = webidl.util.ConvertToInt(V, 32, "unsigned"); |
| 7954 | return x; |
| 7955 | }; |
| 7956 | webidl.converters["unsigned short"] = function(V, opts) { |
| 7957 | const x = webidl.util.ConvertToInt(V, 16, "unsigned", opts); |
| 7958 | return x; |
| 7959 | }; |
| 7960 | webidl.converters.ArrayBuffer = function(V, opts = {}) { |
| 7961 | if (webidl.util.Type(V) !== "Object" || !types.isAnyArrayBuffer(V)) { |
| 7962 | throw webidl.errors.conversionFailed({ |
| 7963 | prefix: `${V}`, |
| 7964 | argument: `${V}`, |
| 7965 | types: ["ArrayBuffer"] |
| 7966 | }); |
| 7967 | } |
| 7968 | if (opts.allowShared === false && types.isSharedArrayBuffer(V)) { |
| 7969 | throw webidl.errors.exception({ |
| 7970 | header: "ArrayBuffer", |
| 7971 | message: "SharedArrayBuffer is not allowed." |
| 7972 | }); |
| 7973 | } |
| 7974 | return V; |
| 7975 | }; |
| 7976 | webidl.converters.TypedArray = function(V, T, opts = {}) { |
| 7977 | if (webidl.util.Type(V) !== "Object" || !types.isTypedArray(V) || V.constructor.name !== T.name) { |
| 7978 | throw webidl.errors.conversionFailed({ |
| 7979 | prefix: `${T.name}`, |
| 7980 | argument: `${V}`, |
| 7981 | types: [T.name] |
| 7982 | }); |
| 7983 | } |
| 7984 | if (opts.allowShared === false && types.isSharedArrayBuffer(V.buffer)) { |
| 7985 | throw webidl.errors.exception({ |
| 7986 | header: "ArrayBuffer", |
| 7987 | message: "SharedArrayBuffer is not allowed." |
| 7988 | }); |
| 7989 | } |
| 7990 | return V; |
| 7991 | }; |
| 7992 | webidl.converters.DataView = function(V, opts = {}) { |
| 7993 | if (webidl.util.Type(V) !== "Object" || !types.isDataView(V)) { |
| 7994 | throw webidl.errors.exception({ |
| 7995 | header: "DataView", |
| 7996 | message: "Object is not a DataView." |
| 7997 | }); |
| 7998 | } |
| 7999 | if (opts.allowShared === false && types.isSharedArrayBuffer(V.buffer)) { |
| 8000 | throw webidl.errors.exception({ |
| 8001 | header: "ArrayBuffer", |
| 8002 | message: "SharedArrayBuffer is not allowed." |
| 8003 | }); |
| 8004 | } |
| 8005 | return V; |
| 8006 | }; |
| 8007 | webidl.converters.BufferSource = function(V, opts = {}) { |
| 8008 | if (types.isAnyArrayBuffer(V)) { |
| 8009 | return webidl.converters.ArrayBuffer(V, opts); |
| 8010 | } |
| 8011 | if (types.isTypedArray(V)) { |
| 8012 | return webidl.converters.TypedArray(V, V.constructor); |
| 8013 | } |
| 8014 | if (types.isDataView(V)) { |
| 8015 | return webidl.converters.DataView(V, opts); |
| 8016 | } |
| 8017 | throw new TypeError(`Could not convert ${V} to a BufferSource.`); |
| 8018 | }; |
| 8019 | webidl.converters["sequence<ByteString>"] = webidl.sequenceConverter( |
| 8020 | webidl.converters.ByteString |
| 8021 | ); |
| 8022 | webidl.converters["sequence<sequence<ByteString>>"] = webidl.sequenceConverter( |
| 8023 | webidl.converters["sequence<ByteString>"] |
| 8024 | ); |
| 8025 | webidl.converters["record<ByteString, ByteString>"] = webidl.recordConverter( |
| 8026 | webidl.converters.ByteString, |
| 8027 | webidl.converters.ByteString |
| 8028 | ); |
| 8029 | module2.exports = { |
| 8030 | webidl |
| 8031 | }; |
| 8032 | } |
| 8033 | }); |
| 8034 | |
| 8035 | // node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/fetch/dataURL.js |
| 8036 | var require_dataURL = __commonJS({ |
| 8037 | "node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/fetch/dataURL.js"(exports2, module2) { |
| 8038 | var assert = require("assert"); |
| 8039 | var { atob: atob2 } = require("buffer"); |
| 8040 | var { isomorphicDecode } = require_util2(); |
| 8041 | var encoder = new TextEncoder(); |
| 8042 | var HTTP_TOKEN_CODEPOINTS = /^[!#$%&'*+-.^_|~A-Za-z0-9]+$/; |
| 8043 | var HTTP_WHITESPACE_REGEX = /(\u000A|\u000D|\u0009|\u0020)/; |
| 8044 | var HTTP_QUOTED_STRING_TOKENS = /[\u0009|\u0020-\u007E|\u0080-\u00FF]/; |
| 8045 | function dataURLProcessor(dataURL) { |
| 8046 | assert(dataURL.protocol === "data:"); |
| 8047 | let input = URLSerializer(dataURL, true); |
| 8048 | input = input.slice(5); |
| 8049 | const position = { position: 0 }; |
| 8050 | let mimeType = collectASequenceOfCodePointsFast( |
| 8051 | ",", |
| 8052 | input, |
| 8053 | position |
| 8054 | ); |
| 8055 | const mimeTypeLength = mimeType.length; |
| 8056 | mimeType = removeASCIIWhitespace(mimeType, true, true); |
| 8057 | if (position.position >= input.length) { |
| 8058 | return "failure"; |
| 8059 | } |
| 8060 | position.position++; |
| 8061 | const encodedBody = input.slice(mimeTypeLength + 1); |
| 8062 | let body = stringPercentDecode(encodedBody); |
| 8063 | if (/;(\u0020){0,}base64$/i.test(mimeType)) { |
| 8064 | const stringBody = isomorphicDecode(body); |
| 8065 | body = forgivingBase64(stringBody); |
| 8066 | if (body === "failure") { |
| 8067 | return "failure"; |
| 8068 | } |
| 8069 | mimeType = mimeType.slice(0, -6); |
| 8070 | mimeType = mimeType.replace(/(\u0020)+$/, ""); |
| 8071 | mimeType = mimeType.slice(0, -1); |
| 8072 | } |
| 8073 | if (mimeType.startsWith(";")) { |
| 8074 | mimeType = "text/plain" + mimeType; |
| 8075 | } |
| 8076 | let mimeTypeRecord = parseMIMEType(mimeType); |
| 8077 | if (mimeTypeRecord === "failure") { |
| 8078 | mimeTypeRecord = parseMIMEType("text/plain;charset=US-ASCII"); |
| 8079 | } |
| 8080 | return { mimeType: mimeTypeRecord, body }; |
| 8081 | } |
| 8082 | function URLSerializer(url, excludeFragment = false) { |
| 8083 | if (!excludeFragment) { |
| 8084 | return url.href; |
| 8085 | } |
| 8086 | const href = url.href; |
| 8087 | const hashLength = url.hash.length; |
| 8088 | return hashLength === 0 ? href : href.substring(0, href.length - hashLength); |
| 8089 | } |
| 8090 | function collectASequenceOfCodePoints(condition, input, position) { |
| 8091 | let result = ""; |
| 8092 | while (position.position < input.length && condition(input[position.position])) { |
| 8093 | result += input[position.position]; |
| 8094 | position.position++; |
| 8095 | } |
| 8096 | return result; |
| 8097 | } |
| 8098 | function collectASequenceOfCodePointsFast(char, input, position) { |
| 8099 | const idx = input.indexOf(char, position.position); |
| 8100 | const start = position.position; |
| 8101 | if (idx === -1) { |
| 8102 | position.position = input.length; |
| 8103 | return input.slice(start); |
| 8104 | } |
| 8105 | position.position = idx; |
| 8106 | return input.slice(start, position.position); |
| 8107 | } |
| 8108 | function stringPercentDecode(input) { |
| 8109 | const bytes = encoder.encode(input); |
| 8110 | return percentDecode(bytes); |
| 8111 | } |
| 8112 | function percentDecode(input) { |
| 8113 | const output = []; |
| 8114 | for (let i = 0; i < input.length; i++) { |
| 8115 | const byte = input[i]; |
| 8116 | if (byte !== 37) { |
| 8117 | output.push(byte); |
| 8118 | } else if (byte === 37 && !/^[0-9A-Fa-f]{2}$/i.test(String.fromCharCode(input[i + 1], input[i + 2]))) { |
| 8119 | output.push(37); |
| 8120 | } else { |
| 8121 | const nextTwoBytes = String.fromCharCode(input[i + 1], input[i + 2]); |
| 8122 | const bytePoint = Number.parseInt(nextTwoBytes, 16); |
| 8123 | output.push(bytePoint); |
| 8124 | i += 2; |
| 8125 | } |
| 8126 | } |
| 8127 | return Uint8Array.from(output); |
| 8128 | } |
| 8129 | function parseMIMEType(input) { |
| 8130 | input = removeHTTPWhitespace(input, true, true); |
| 8131 | const position = { position: 0 }; |
| 8132 | const type = collectASequenceOfCodePointsFast( |
| 8133 | "/", |
| 8134 | input, |
| 8135 | position |
| 8136 | ); |
| 8137 | if (type.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(type)) { |
| 8138 | return "failure"; |
| 8139 | } |
| 8140 | if (position.position > input.length) { |
| 8141 | return "failure"; |
| 8142 | } |
| 8143 | position.position++; |
| 8144 | let subtype = collectASequenceOfCodePointsFast( |
| 8145 | ";", |
| 8146 | input, |
| 8147 | position |
| 8148 | ); |
| 8149 | subtype = removeHTTPWhitespace(subtype, false, true); |
| 8150 | if (subtype.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(subtype)) { |
| 8151 | return "failure"; |
| 8152 | } |
| 8153 | const typeLowercase = type.toLowerCase(); |
| 8154 | const subtypeLowercase = subtype.toLowerCase(); |
| 8155 | const mimeType = { |
| 8156 | type: typeLowercase, |
| 8157 | subtype: subtypeLowercase, |
| 8158 | /** @type {Map<string, string>} */ |
| 8159 | parameters: /* @__PURE__ */ new Map(), |
| 8160 | // https://mimesniff.spec.whatwg.org/#mime-type-essence |
| 8161 | essence: `${typeLowercase}/${subtypeLowercase}` |
| 8162 | }; |
| 8163 | while (position.position < input.length) { |
| 8164 | position.position++; |
| 8165 | collectASequenceOfCodePoints( |
| 8166 | // https://fetch.spec.whatwg.org/#http-whitespace |
| 8167 | (char) => HTTP_WHITESPACE_REGEX.test(char), |
| 8168 | input, |
| 8169 | position |
| 8170 | ); |
| 8171 | let parameterName = collectASequenceOfCodePoints( |
| 8172 | (char) => char !== ";" && char !== "=", |
| 8173 | input, |
| 8174 | position |
| 8175 | ); |
| 8176 | parameterName = parameterName.toLowerCase(); |
| 8177 | if (position.position < input.length) { |
| 8178 | if (input[position.position] === ";") { |
| 8179 | continue; |
| 8180 | } |
| 8181 | position.position++; |
| 8182 | } |
| 8183 | if (position.position > input.length) { |
| 8184 | break; |
| 8185 | } |
| 8186 | let parameterValue = null; |
| 8187 | if (input[position.position] === '"') { |
| 8188 | parameterValue = collectAnHTTPQuotedString(input, position, true); |
| 8189 | collectASequenceOfCodePointsFast( |
| 8190 | ";", |
| 8191 | input, |
| 8192 | position |
| 8193 | ); |
| 8194 | } else { |
| 8195 | parameterValue = collectASequenceOfCodePointsFast( |
| 8196 | ";", |
| 8197 | input, |
| 8198 | position |
| 8199 | ); |
| 8200 | parameterValue = removeHTTPWhitespace(parameterValue, false, true); |
| 8201 | if (parameterValue.length === 0) { |
| 8202 | continue; |
| 8203 | } |
| 8204 | } |
| 8205 | if (parameterName.length !== 0 && HTTP_TOKEN_CODEPOINTS.test(parameterName) && (parameterValue.length === 0 || HTTP_QUOTED_STRING_TOKENS.test(parameterValue)) && !mimeType.parameters.has(parameterName)) { |
| 8206 | mimeType.parameters.set(parameterName, parameterValue); |
| 8207 | } |
| 8208 | } |
| 8209 | return mimeType; |
| 8210 | } |
| 8211 | function forgivingBase64(data) { |
| 8212 | data = data.replace(/[\u0009\u000A\u000C\u000D\u0020]/g, ""); |
| 8213 | if (data.length % 4 === 0) { |
| 8214 | data = data.replace(/=?=$/, ""); |
| 8215 | } |
| 8216 | if (data.length % 4 === 1) { |
| 8217 | return "failure"; |
| 8218 | } |
| 8219 | if (/[^+/0-9A-Za-z]/.test(data)) { |
| 8220 | return "failure"; |
| 8221 | } |
| 8222 | const binary = atob2(data); |
| 8223 | const bytes = new Uint8Array(binary.length); |
| 8224 | for (let byte = 0; byte < binary.length; byte++) { |
| 8225 | bytes[byte] = binary.charCodeAt(byte); |
| 8226 | } |
| 8227 | return bytes; |
| 8228 | } |
| 8229 | function collectAnHTTPQuotedString(input, position, extractValue) { |
| 8230 | const positionStart = position.position; |
| 8231 | let value = ""; |
| 8232 | assert(input[position.position] === '"'); |
| 8233 | position.position++; |
| 8234 | while (true) { |
| 8235 | value += collectASequenceOfCodePoints( |
| 8236 | (char) => char !== '"' && char !== "\\", |
| 8237 | input, |
| 8238 | position |
| 8239 | ); |
| 8240 | if (position.position >= input.length) { |
| 8241 | break; |
| 8242 | } |
| 8243 | const quoteOrBackslash = input[position.position]; |
| 8244 | position.position++; |
| 8245 | if (quoteOrBackslash === "\\") { |
| 8246 | if (position.position >= input.length) { |
| 8247 | value += "\\"; |
| 8248 | break; |
| 8249 | } |
| 8250 | value += input[position.position]; |
| 8251 | position.position++; |
| 8252 | } else { |
| 8253 | assert(quoteOrBackslash === '"'); |
| 8254 | break; |
| 8255 | } |
| 8256 | } |
| 8257 | if (extractValue) { |
| 8258 | return value; |
| 8259 | } |
| 8260 | return input.slice(positionStart, position.position); |
| 8261 | } |
| 8262 | function serializeAMimeType(mimeType) { |
| 8263 | assert(mimeType !== "failure"); |
| 8264 | const { parameters, essence } = mimeType; |
| 8265 | let serialization = essence; |
| 8266 | for (let [name, value] of parameters.entries()) { |
| 8267 | serialization += ";"; |
| 8268 | serialization += name; |
| 8269 | serialization += "="; |
| 8270 | if (!HTTP_TOKEN_CODEPOINTS.test(value)) { |
| 8271 | value = value.replace(/(\\|")/g, "\\$1"); |
| 8272 | value = '"' + value; |
| 8273 | value += '"'; |
| 8274 | } |
| 8275 | serialization += value; |
| 8276 | } |
| 8277 | return serialization; |
| 8278 | } |
| 8279 | function isHTTPWhiteSpace(char) { |
| 8280 | return char === "\r" || char === "\n" || char === " " || char === " "; |
| 8281 | } |
| 8282 | function removeHTTPWhitespace(str, leading = true, trailing = true) { |
| 8283 | let lead = 0; |
| 8284 | let trail = str.length - 1; |
| 8285 | if (leading) { |
| 8286 | for (; lead < str.length && isHTTPWhiteSpace(str[lead]); lead++) ; |
| 8287 | } |
| 8288 | if (trailing) { |
| 8289 | for (; trail > 0 && isHTTPWhiteSpace(str[trail]); trail--) ; |
| 8290 | } |
| 8291 | return str.slice(lead, trail + 1); |
| 8292 | } |
| 8293 | function isASCIIWhitespace(char) { |
| 8294 | return char === "\r" || char === "\n" || char === " " || char === "\f" || char === " "; |
| 8295 | } |
| 8296 | function removeASCIIWhitespace(str, leading = true, trailing = true) { |
| 8297 | let lead = 0; |
| 8298 | let trail = str.length - 1; |
| 8299 | if (leading) { |
| 8300 | for (; lead < str.length && isASCIIWhitespace(str[lead]); lead++) ; |
| 8301 | } |
| 8302 | if (trailing) { |
| 8303 | for (; trail > 0 && isASCIIWhitespace(str[trail]); trail--) ; |
| 8304 | } |
| 8305 | return str.slice(lead, trail + 1); |
| 8306 | } |
| 8307 | module2.exports = { |
| 8308 | dataURLProcessor, |
| 8309 | URLSerializer, |
| 8310 | collectASequenceOfCodePoints, |
| 8311 | collectASequenceOfCodePointsFast, |
| 8312 | stringPercentDecode, |
| 8313 | parseMIMEType, |
| 8314 | collectAnHTTPQuotedString, |
| 8315 | serializeAMimeType |
| 8316 | }; |
| 8317 | } |
| 8318 | }); |
| 8319 | |
| 8320 | // node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/fetch/file.js |
| 8321 | var require_file = __commonJS({ |
| 8322 | "node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/fetch/file.js"(exports2, module2) { |
| 8323 | "use strict"; |
| 8324 | var { Blob: Blob2, File: NativeFile } = require("buffer"); |
| 8325 | var { types } = require("util"); |
| 8326 | var { kState } = require_symbols2(); |
| 8327 | var { isBlobLike } = require_util2(); |
| 8328 | var { webidl } = require_webidl(); |
| 8329 | var { parseMIMEType, serializeAMimeType } = require_dataURL(); |
| 8330 | var { kEnumerableProperty } = require_util(); |
| 8331 | var encoder = new TextEncoder(); |
| 8332 | var File = class _File extends Blob2 { |
| 8333 | constructor(fileBits, fileName, options = {}) { |
| 8334 | webidl.argumentLengthCheck(arguments, 2, { header: "File constructor" }); |
| 8335 | fileBits = webidl.converters["sequence<BlobPart>"](fileBits); |
| 8336 | fileName = webidl.converters.USVString(fileName); |
| 8337 | options = webidl.converters.FilePropertyBag(options); |
| 8338 | const n = fileName; |
| 8339 | let t = options.type; |
| 8340 | let d; |
| 8341 | substep: { |
| 8342 | if (t) { |
| 8343 | t = parseMIMEType(t); |
| 8344 | if (t === "failure") { |
| 8345 | t = ""; |
| 8346 | break substep; |
| 8347 | } |
| 8348 | t = serializeAMimeType(t).toLowerCase(); |
| 8349 | } |
| 8350 | d = options.lastModified; |
| 8351 | } |
| 8352 | super(processBlobParts(fileBits, options), { type: t }); |
| 8353 | this[kState] = { |
| 8354 | name: n, |
| 8355 | lastModified: d, |
| 8356 | type: t |
| 8357 | }; |
| 8358 | } |
| 8359 | get name() { |
| 8360 | webidl.brandCheck(this, _File); |
| 8361 | return this[kState].name; |
| 8362 | } |
| 8363 | get lastModified() { |
| 8364 | webidl.brandCheck(this, _File); |
| 8365 | return this[kState].lastModified; |
| 8366 | } |
| 8367 | get type() { |
| 8368 | webidl.brandCheck(this, _File); |
| 8369 | return this[kState].type; |
| 8370 | } |
| 8371 | }; |
| 8372 | var FileLike = class _FileLike { |
| 8373 | constructor(blobLike, fileName, options = {}) { |
| 8374 | const n = fileName; |
| 8375 | const t = options.type; |
| 8376 | const d = options.lastModified ?? Date.now(); |
| 8377 | this[kState] = { |
| 8378 | blobLike, |
| 8379 | name: n, |
| 8380 | type: t, |
| 8381 | lastModified: d |
| 8382 | }; |
| 8383 | } |
| 8384 | stream(...args) { |
| 8385 | webidl.brandCheck(this, _FileLike); |
| 8386 | return this[kState].blobLike.stream(...args); |
| 8387 | } |
| 8388 | arrayBuffer(...args) { |
| 8389 | webidl.brandCheck(this, _FileLike); |
| 8390 | return this[kState].blobLike.arrayBuffer(...args); |
| 8391 | } |
| 8392 | slice(...args) { |
| 8393 | webidl.brandCheck(this, _FileLike); |
| 8394 | return this[kState].blobLike.slice(...args); |
| 8395 | } |
| 8396 | text(...args) { |
| 8397 | webidl.brandCheck(this, _FileLike); |
| 8398 | return this[kState].blobLike.text(...args); |
| 8399 | } |
| 8400 | get size() { |
| 8401 | webidl.brandCheck(this, _FileLike); |
| 8402 | return this[kState].blobLike.size; |
| 8403 | } |
| 8404 | get type() { |
| 8405 | webidl.brandCheck(this, _FileLike); |
| 8406 | return this[kState].blobLike.type; |
| 8407 | } |
| 8408 | get name() { |
| 8409 | webidl.brandCheck(this, _FileLike); |
| 8410 | return this[kState].name; |
| 8411 | } |
| 8412 | get lastModified() { |
| 8413 | webidl.brandCheck(this, _FileLike); |
| 8414 | return this[kState].lastModified; |
| 8415 | } |
| 8416 | get [Symbol.toStringTag]() { |
| 8417 | return "File"; |
| 8418 | } |
| 8419 | }; |
| 8420 | Object.defineProperties(File.prototype, { |
| 8421 | [Symbol.toStringTag]: { |
| 8422 | value: "File", |
| 8423 | configurable: true |
| 8424 | }, |
| 8425 | name: kEnumerableProperty, |
| 8426 | lastModified: kEnumerableProperty |
| 8427 | }); |
| 8428 | webidl.converters.Blob = webidl.interfaceConverter(Blob2); |
| 8429 | webidl.converters.BlobPart = function(V, opts) { |
| 8430 | if (webidl.util.Type(V) === "Object") { |
| 8431 | if (isBlobLike(V)) { |
| 8432 | return webidl.converters.Blob(V, { strict: false }); |
| 8433 | } |
| 8434 | if (ArrayBuffer.isView(V) || types.isAnyArrayBuffer(V)) { |
| 8435 | return webidl.converters.BufferSource(V, opts); |
| 8436 | } |
| 8437 | } |
| 8438 | return webidl.converters.USVString(V, opts); |
| 8439 | }; |
| 8440 | webidl.converters["sequence<BlobPart>"] = webidl.sequenceConverter( |
| 8441 | webidl.converters.BlobPart |
| 8442 | ); |
| 8443 | webidl.converters.FilePropertyBag = webidl.dictionaryConverter([ |
| 8444 | { |
| 8445 | key: "lastModified", |
| 8446 | converter: webidl.converters["long long"], |
| 8447 | get defaultValue() { |
| 8448 | return Date.now(); |
| 8449 | } |
| 8450 | }, |
| 8451 | { |
| 8452 | key: "type", |
| 8453 | converter: webidl.converters.DOMString, |
| 8454 | defaultValue: "" |
| 8455 | }, |
| 8456 | { |
| 8457 | key: "endings", |
| 8458 | converter: (value) => { |
| 8459 | value = webidl.converters.DOMString(value); |
| 8460 | value = value.toLowerCase(); |
| 8461 | if (value !== "native") { |
| 8462 | value = "transparent"; |
| 8463 | } |
| 8464 | return value; |
| 8465 | }, |
| 8466 | defaultValue: "transparent" |
| 8467 | } |
| 8468 | ]); |
| 8469 | function processBlobParts(parts, options) { |
| 8470 | const bytes = []; |
| 8471 | for (const element of parts) { |
| 8472 | if (typeof element === "string") { |
| 8473 | let s = element; |
| 8474 | if (options.endings === "native") { |
| 8475 | s = convertLineEndingsNative(s); |
| 8476 | } |
| 8477 | bytes.push(encoder.encode(s)); |
| 8478 | } else if (types.isAnyArrayBuffer(element) || types.isTypedArray(element)) { |
| 8479 | if (!element.buffer) { |
| 8480 | bytes.push(new Uint8Array(element)); |
| 8481 | } else { |
| 8482 | bytes.push( |
| 8483 | new Uint8Array(element.buffer, element.byteOffset, element.byteLength) |
| 8484 | ); |
| 8485 | } |
| 8486 | } else if (isBlobLike(element)) { |
| 8487 | bytes.push(element); |
| 8488 | } |
| 8489 | } |
| 8490 | return bytes; |
| 8491 | } |
| 8492 | function convertLineEndingsNative(s) { |
| 8493 | let nativeLineEnding = "\n"; |
| 8494 | if (process.platform === "win32") { |
| 8495 | nativeLineEnding = "\r\n"; |
| 8496 | } |
| 8497 | return s.replace(/\r?\n/g, nativeLineEnding); |
| 8498 | } |
| 8499 | function isFileLike(object) { |
| 8500 | return NativeFile && object instanceof NativeFile || object instanceof File || object && (typeof object.stream === "function" || typeof object.arrayBuffer === "function") && object[Symbol.toStringTag] === "File"; |
| 8501 | } |
| 8502 | module2.exports = { File, FileLike, isFileLike }; |
| 8503 | } |
| 8504 | }); |
| 8505 | |
| 8506 | // node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/fetch/formdata.js |
| 8507 | var require_formdata = __commonJS({ |
| 8508 | "node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/fetch/formdata.js"(exports2, module2) { |
| 8509 | "use strict"; |
| 8510 | var { isBlobLike, toUSVString, makeIterator } = require_util2(); |
| 8511 | var { kState } = require_symbols2(); |
| 8512 | var { File: UndiciFile, FileLike, isFileLike } = require_file(); |
| 8513 | var { webidl } = require_webidl(); |
| 8514 | var { Blob: Blob2, File: NativeFile } = require("buffer"); |
| 8515 | var File = NativeFile ?? UndiciFile; |
| 8516 | var FormData = class _FormData { |
| 8517 | constructor(form) { |
| 8518 | if (form !== void 0) { |
| 8519 | throw webidl.errors.conversionFailed({ |
| 8520 | prefix: "FormData constructor", |
| 8521 | argument: "Argument 1", |
| 8522 | types: ["undefined"] |
| 8523 | }); |
| 8524 | } |
| 8525 | this[kState] = []; |
| 8526 | } |
| 8527 | append(name, value, filename = void 0) { |
| 8528 | webidl.brandCheck(this, _FormData); |
| 8529 | webidl.argumentLengthCheck(arguments, 2, { header: "FormData.append" }); |
| 8530 | if (arguments.length === 3 && !isBlobLike(value)) { |
| 8531 | throw new TypeError( |
| 8532 | "Failed to execute 'append' on 'FormData': parameter 2 is not of type 'Blob'" |
| 8533 | ); |
| 8534 | } |
| 8535 | name = webidl.converters.USVString(name); |
| 8536 | value = isBlobLike(value) ? webidl.converters.Blob(value, { strict: false }) : webidl.converters.USVString(value); |
| 8537 | filename = arguments.length === 3 ? webidl.converters.USVString(filename) : void 0; |
| 8538 | const entry = makeEntry(name, value, filename); |
| 8539 | this[kState].push(entry); |
| 8540 | } |
| 8541 | delete(name) { |
| 8542 | webidl.brandCheck(this, _FormData); |
| 8543 | webidl.argumentLengthCheck(arguments, 1, { header: "FormData.delete" }); |
| 8544 | name = webidl.converters.USVString(name); |
| 8545 | this[kState] = this[kState].filter((entry) => entry.name !== name); |
| 8546 | } |
| 8547 | get(name) { |
| 8548 | webidl.brandCheck(this, _FormData); |
| 8549 | webidl.argumentLengthCheck(arguments, 1, { header: "FormData.get" }); |
| 8550 | name = webidl.converters.USVString(name); |
| 8551 | const idx = this[kState].findIndex((entry) => entry.name === name); |
| 8552 | if (idx === -1) { |
| 8553 | return null; |
| 8554 | } |
| 8555 | return this[kState][idx].value; |
| 8556 | } |
| 8557 | getAll(name) { |
| 8558 | webidl.brandCheck(this, _FormData); |
| 8559 | webidl.argumentLengthCheck(arguments, 1, { header: "FormData.getAll" }); |
| 8560 | name = webidl.converters.USVString(name); |
| 8561 | return this[kState].filter((entry) => entry.name === name).map((entry) => entry.value); |
| 8562 | } |
| 8563 | has(name) { |
| 8564 | webidl.brandCheck(this, _FormData); |
| 8565 | webidl.argumentLengthCheck(arguments, 1, { header: "FormData.has" }); |
| 8566 | name = webidl.converters.USVString(name); |
| 8567 | return this[kState].findIndex((entry) => entry.name === name) !== -1; |
| 8568 | } |
| 8569 | set(name, value, filename = void 0) { |
| 8570 | webidl.brandCheck(this, _FormData); |
| 8571 | webidl.argumentLengthCheck(arguments, 2, { header: "FormData.set" }); |
| 8572 | if (arguments.length === 3 && !isBlobLike(value)) { |
| 8573 | throw new TypeError( |
| 8574 | "Failed to execute 'set' on 'FormData': parameter 2 is not of type 'Blob'" |
| 8575 | ); |
| 8576 | } |
| 8577 | name = webidl.converters.USVString(name); |
| 8578 | value = isBlobLike(value) ? webidl.converters.Blob(value, { strict: false }) : webidl.converters.USVString(value); |
| 8579 | filename = arguments.length === 3 ? toUSVString(filename) : void 0; |
| 8580 | const entry = makeEntry(name, value, filename); |
| 8581 | const idx = this[kState].findIndex((entry2) => entry2.name === name); |
| 8582 | if (idx !== -1) { |
| 8583 | this[kState] = [ |
| 8584 | ...this[kState].slice(0, idx), |
| 8585 | entry, |
| 8586 | ...this[kState].slice(idx + 1).filter((entry2) => entry2.name !== name) |
| 8587 | ]; |
| 8588 | } else { |
| 8589 | this[kState].push(entry); |
| 8590 | } |
| 8591 | } |
| 8592 | entries() { |
| 8593 | webidl.brandCheck(this, _FormData); |
| 8594 | return makeIterator( |
| 8595 | () => this[kState].map((pair) => [pair.name, pair.value]), |
| 8596 | "FormData", |
| 8597 | "key+value" |
| 8598 | ); |
| 8599 | } |
| 8600 | keys() { |
| 8601 | webidl.brandCheck(this, _FormData); |
| 8602 | return makeIterator( |
| 8603 | () => this[kState].map((pair) => [pair.name, pair.value]), |
| 8604 | "FormData", |
| 8605 | "key" |
| 8606 | ); |
| 8607 | } |
| 8608 | values() { |
| 8609 | webidl.brandCheck(this, _FormData); |
| 8610 | return makeIterator( |
| 8611 | () => this[kState].map((pair) => [pair.name, pair.value]), |
| 8612 | "FormData", |
| 8613 | "value" |
| 8614 | ); |
| 8615 | } |
| 8616 | /** |
| 8617 | * @param {(value: string, key: string, self: FormData) => void} callbackFn |
| 8618 | * @param {unknown} thisArg |
| 8619 | */ |
| 8620 | forEach(callbackFn, thisArg = globalThis) { |
| 8621 | webidl.brandCheck(this, _FormData); |
| 8622 | webidl.argumentLengthCheck(arguments, 1, { header: "FormData.forEach" }); |
| 8623 | if (typeof callbackFn !== "function") { |
| 8624 | throw new TypeError( |
| 8625 | "Failed to execute 'forEach' on 'FormData': parameter 1 is not of type 'Function'." |
| 8626 | ); |
| 8627 | } |
| 8628 | for (const [key, value] of this) { |
| 8629 | callbackFn.apply(thisArg, [value, key, this]); |
| 8630 | } |
| 8631 | } |
| 8632 | }; |
| 8633 | FormData.prototype[Symbol.iterator] = FormData.prototype.entries; |
| 8634 | Object.defineProperties(FormData.prototype, { |
| 8635 | [Symbol.toStringTag]: { |
| 8636 | value: "FormData", |
| 8637 | configurable: true |
| 8638 | } |
| 8639 | }); |
| 8640 | function makeEntry(name, value, filename) { |
| 8641 | name = Buffer.from(name).toString("utf8"); |
| 8642 | if (typeof value === "string") { |
| 8643 | value = Buffer.from(value).toString("utf8"); |
| 8644 | } else { |
| 8645 | if (!isFileLike(value)) { |
| 8646 | value = value instanceof Blob2 ? new File([value], "blob", { type: value.type }) : new FileLike(value, "blob", { type: value.type }); |
| 8647 | } |
| 8648 | if (filename !== void 0) { |
| 8649 | const options = { |
| 8650 | type: value.type, |
| 8651 | lastModified: value.lastModified |
| 8652 | }; |
| 8653 | value = NativeFile && value instanceof NativeFile || value instanceof UndiciFile ? new File([value], filename, options) : new FileLike(value, filename, options); |
| 8654 | } |
| 8655 | } |
| 8656 | return { name, value }; |
| 8657 | } |
| 8658 | module2.exports = { FormData }; |
| 8659 | } |
| 8660 | }); |
| 8661 | |
| 8662 | // node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/fetch/body.js |
| 8663 | var require_body = __commonJS({ |
| 8664 | "node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/fetch/body.js"(exports2, module2) { |
| 8665 | "use strict"; |
| 8666 | var Busboy = require_main(); |
| 8667 | var util = require_util(); |
| 8668 | var { |
| 8669 | ReadableStreamFrom, |
| 8670 | isBlobLike, |
| 8671 | isReadableStreamLike, |
| 8672 | readableStreamClose, |
| 8673 | createDeferredPromise, |
| 8674 | fullyReadBody |
| 8675 | } = require_util2(); |
| 8676 | var { FormData } = require_formdata(); |
| 8677 | var { kState } = require_symbols2(); |
| 8678 | var { webidl } = require_webidl(); |
| 8679 | var { DOMException: DOMException2, structuredClone } = require_constants2(); |
| 8680 | var { Blob: Blob2, File: NativeFile } = require("buffer"); |
| 8681 | var { kBodyUsed } = require_symbols(); |
| 8682 | var assert = require("assert"); |
| 8683 | var { isErrored } = require_util(); |
| 8684 | var { isUint8Array, isArrayBuffer } = require("util/types"); |
| 8685 | var { File: UndiciFile } = require_file(); |
| 8686 | var { parseMIMEType, serializeAMimeType } = require_dataURL(); |
| 8687 | var random; |
| 8688 | try { |
| 8689 | const crypto = require("node:crypto"); |
| 8690 | random = (max) => crypto.randomInt(0, max); |
| 8691 | } catch { |
| 8692 | random = (max) => Math.floor(Math.random(max)); |
| 8693 | } |
| 8694 | var ReadableStream = globalThis.ReadableStream; |
| 8695 | var File = NativeFile ?? UndiciFile; |
| 8696 | var textEncoder = new TextEncoder(); |
| 8697 | var textDecoder = new TextDecoder(); |
| 8698 | function extractBody(object, keepalive = false) { |
| 8699 | if (!ReadableStream) { |
| 8700 | ReadableStream = require("stream/web").ReadableStream; |
| 8701 | } |
| 8702 | let stream = null; |
| 8703 | if (object instanceof ReadableStream) { |
| 8704 | stream = object; |
| 8705 | } else if (isBlobLike(object)) { |
| 8706 | stream = object.stream(); |
| 8707 | } else { |
| 8708 | stream = new ReadableStream({ |
| 8709 | async pull(controller) { |
| 8710 | controller.enqueue( |
| 8711 | typeof source === "string" ? textEncoder.encode(source) : source |
| 8712 | ); |
| 8713 | queueMicrotask(() => readableStreamClose(controller)); |
| 8714 | }, |
| 8715 | start() { |
| 8716 | }, |
| 8717 | type: void 0 |
| 8718 | }); |
| 8719 | } |
| 8720 | assert(isReadableStreamLike(stream)); |
| 8721 | let action = null; |
| 8722 | let source = null; |
| 8723 | let length = null; |
| 8724 | let type = null; |
| 8725 | if (typeof object === "string") { |
| 8726 | source = object; |
| 8727 | type = "text/plain;charset=UTF-8"; |
| 8728 | } else if (object instanceof URLSearchParams) { |
| 8729 | source = object.toString(); |
| 8730 | type = "application/x-www-form-urlencoded;charset=UTF-8"; |
| 8731 | } else if (isArrayBuffer(object)) { |
| 8732 | source = new Uint8Array(object.slice()); |
| 8733 | } else if (ArrayBuffer.isView(object)) { |
| 8734 | source = new Uint8Array(object.buffer.slice(object.byteOffset, object.byteOffset + object.byteLength)); |
| 8735 | } else if (util.isFormDataLike(object)) { |
| 8736 | const boundary = `----formdata-undici-0${`${random(1e11)}`.padStart(11, "0")}`; |
| 8737 | const prefix = `--${boundary}\r |
| 8738 | Content-Disposition: form-data`; |
| 8739 | const escape = (str) => str.replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22"); |
| 8740 | const normalizeLinefeeds = (value) => value.replace(/\r?\n|\r/g, "\r\n"); |
| 8741 | const blobParts = []; |
| 8742 | const rn = new Uint8Array([13, 10]); |
| 8743 | length = 0; |
| 8744 | let hasUnknownSizeValue = false; |
| 8745 | for (const [name, value] of object) { |
| 8746 | if (typeof value === "string") { |
| 8747 | const chunk2 = textEncoder.encode(prefix + `; name="${escape(normalizeLinefeeds(name))}"\r |
| 8748 | \r |
| 8749 | ${normalizeLinefeeds(value)}\r |
| 8750 | `); |
| 8751 | blobParts.push(chunk2); |
| 8752 | length += chunk2.byteLength; |
| 8753 | } else { |
| 8754 | const chunk2 = textEncoder.encode(`${prefix}; name="${escape(normalizeLinefeeds(name))}"` + (value.name ? `; filename="${escape(value.name)}"` : "") + `\r |
| 8755 | Content-Type: ${value.type || "application/octet-stream"}\r |
| 8756 | \r |
| 8757 | `); |
| 8758 | blobParts.push(chunk2, value, rn); |
| 8759 | if (typeof value.size === "number") { |
| 8760 | length += chunk2.byteLength + value.size + rn.byteLength; |
| 8761 | } else { |
| 8762 | hasUnknownSizeValue = true; |
| 8763 | } |
| 8764 | } |
| 8765 | } |
| 8766 | const chunk = textEncoder.encode(`--${boundary}--`); |
| 8767 | blobParts.push(chunk); |
| 8768 | length += chunk.byteLength; |
| 8769 | if (hasUnknownSizeValue) { |
| 8770 | length = null; |
| 8771 | } |
| 8772 | source = object; |
| 8773 | action = async function* () { |
| 8774 | for (const part of blobParts) { |
| 8775 | if (part.stream) { |
| 8776 | yield* part.stream(); |
| 8777 | } else { |
| 8778 | yield part; |
| 8779 | } |
| 8780 | } |
| 8781 | }; |
| 8782 | type = "multipart/form-data; boundary=" + boundary; |
| 8783 | } else if (isBlobLike(object)) { |
| 8784 | source = object; |
| 8785 | length = object.size; |
| 8786 | if (object.type) { |
| 8787 | type = object.type; |
| 8788 | } |
| 8789 | } else if (typeof object[Symbol.asyncIterator] === "function") { |
| 8790 | if (keepalive) { |
| 8791 | throw new TypeError("keepalive"); |
| 8792 | } |
| 8793 | if (util.isDisturbed(object) || object.locked) { |
| 8794 | throw new TypeError( |
| 8795 | "Response body object should not be disturbed or locked" |
| 8796 | ); |
| 8797 | } |
| 8798 | stream = object instanceof ReadableStream ? object : ReadableStreamFrom(object); |
| 8799 | } |
| 8800 | if (typeof source === "string" || util.isBuffer(source)) { |
| 8801 | length = Buffer.byteLength(source); |
| 8802 | } |
| 8803 | if (action != null) { |
| 8804 | let iterator2; |
| 8805 | stream = new ReadableStream({ |
| 8806 | async start() { |
| 8807 | iterator2 = action(object)[Symbol.asyncIterator](); |
| 8808 | }, |
| 8809 | async pull(controller) { |
| 8810 | const { value, done } = await iterator2.next(); |
| 8811 | if (done) { |
| 8812 | queueMicrotask(() => { |
| 8813 | controller.close(); |
| 8814 | }); |
| 8815 | } else { |
| 8816 | if (!isErrored(stream)) { |
| 8817 | controller.enqueue(new Uint8Array(value)); |
| 8818 | } |
| 8819 | } |
| 8820 | return controller.desiredSize > 0; |
| 8821 | }, |
| 8822 | async cancel(reason) { |
| 8823 | await iterator2.return(); |
| 8824 | }, |
| 8825 | type: void 0 |
| 8826 | }); |
| 8827 | } |
| 8828 | const body = { stream, source, length }; |
| 8829 | return [body, type]; |
| 8830 | } |
| 8831 | function safelyExtractBody(object, keepalive = false) { |
| 8832 | if (!ReadableStream) { |
| 8833 | ReadableStream = require("stream/web").ReadableStream; |
| 8834 | } |
| 8835 | if (object instanceof ReadableStream) { |
| 8836 | assert(!util.isDisturbed(object), "The body has already been consumed."); |
| 8837 | assert(!object.locked, "The stream is locked."); |
| 8838 | } |
| 8839 | return extractBody(object, keepalive); |
| 8840 | } |
| 8841 | function cloneBody(body) { |
| 8842 | const [out1, out2] = body.stream.tee(); |
| 8843 | const out2Clone = structuredClone(out2, { transfer: [out2] }); |
| 8844 | const [, finalClone] = out2Clone.tee(); |
| 8845 | body.stream = out1; |
| 8846 | return { |
| 8847 | stream: finalClone, |
| 8848 | length: body.length, |
| 8849 | source: body.source |
| 8850 | }; |
| 8851 | } |
| 8852 | async function* consumeBody(body) { |
| 8853 | if (body) { |
| 8854 | if (isUint8Array(body)) { |
| 8855 | yield body; |
| 8856 | } else { |
| 8857 | const stream = body.stream; |
| 8858 | if (util.isDisturbed(stream)) { |
| 8859 | throw new TypeError("The body has already been consumed."); |
| 8860 | } |
| 8861 | if (stream.locked) { |
| 8862 | throw new TypeError("The stream is locked."); |
| 8863 | } |
| 8864 | stream[kBodyUsed] = true; |
| 8865 | yield* stream; |
| 8866 | } |
| 8867 | } |
| 8868 | } |
| 8869 | function throwIfAborted(state) { |
| 8870 | if (state.aborted) { |
| 8871 | throw new DOMException2("The operation was aborted.", "AbortError"); |
| 8872 | } |
| 8873 | } |
| 8874 | function bodyMixinMethods(instance) { |
| 8875 | const methods = { |
| 8876 | blob() { |
| 8877 | return specConsumeBody(this, (bytes) => { |
| 8878 | let mimeType = bodyMimeType(this); |
| 8879 | if (mimeType === "failure") { |
| 8880 | mimeType = ""; |
| 8881 | } else if (mimeType) { |
| 8882 | mimeType = serializeAMimeType(mimeType); |
| 8883 | } |
| 8884 | return new Blob2([bytes], { type: mimeType }); |
| 8885 | }, instance); |
| 8886 | }, |
| 8887 | arrayBuffer() { |
| 8888 | return specConsumeBody(this, (bytes) => { |
| 8889 | return new Uint8Array(bytes).buffer; |
| 8890 | }, instance); |
| 8891 | }, |
| 8892 | text() { |
| 8893 | return specConsumeBody(this, utf8DecodeBytes, instance); |
| 8894 | }, |
| 8895 | json() { |
| 8896 | return specConsumeBody(this, parseJSONFromBytes, instance); |
| 8897 | }, |
| 8898 | async formData() { |
| 8899 | webidl.brandCheck(this, instance); |
| 8900 | throwIfAborted(this[kState]); |
| 8901 | const contentType = this.headers.get("Content-Type"); |
| 8902 | if (/multipart\/form-data/.test(contentType)) { |
| 8903 | const headers = {}; |
| 8904 | for (const [key, value] of this.headers) headers[key.toLowerCase()] = value; |
| 8905 | const responseFormData = new FormData(); |
| 8906 | let busboy; |
| 8907 | try { |
| 8908 | busboy = new Busboy({ |
| 8909 | headers, |
| 8910 | preservePath: true |
| 8911 | }); |
| 8912 | } catch (err) { |
| 8913 | throw new DOMException2(`${err}`, "AbortError"); |
| 8914 | } |
| 8915 | busboy.on("field", (name, value) => { |
| 8916 | responseFormData.append(name, value); |
| 8917 | }); |
| 8918 | busboy.on("file", (name, value, filename, encoding, mimeType) => { |
| 8919 | const chunks = []; |
| 8920 | if (encoding === "base64" || encoding.toLowerCase() === "base64") { |
| 8921 | let base64chunk = ""; |
| 8922 | value.on("data", (chunk) => { |
| 8923 | base64chunk += chunk.toString().replace(/[\r\n]/gm, ""); |
| 8924 | const end = base64chunk.length - base64chunk.length % 4; |
| 8925 | chunks.push(Buffer.from(base64chunk.slice(0, end), "base64")); |
| 8926 | base64chunk = base64chunk.slice(end); |
| 8927 | }); |
| 8928 | value.on("end", () => { |
| 8929 | chunks.push(Buffer.from(base64chunk, "base64")); |
| 8930 | responseFormData.append(name, new File(chunks, filename, { type: mimeType })); |
| 8931 | }); |
| 8932 | } else { |
| 8933 | value.on("data", (chunk) => { |
| 8934 | chunks.push(chunk); |
| 8935 | }); |
| 8936 | value.on("end", () => { |
| 8937 | responseFormData.append(name, new File(chunks, filename, { type: mimeType })); |
| 8938 | }); |
| 8939 | } |
| 8940 | }); |
| 8941 | const busboyResolve = new Promise((resolve, reject) => { |
| 8942 | busboy.on("finish", resolve); |
| 8943 | busboy.on("error", (err) => reject(new TypeError(err))); |
| 8944 | }); |
| 8945 | if (this.body !== null) for await (const chunk of consumeBody(this[kState].body)) busboy.write(chunk); |
| 8946 | busboy.end(); |
| 8947 | await busboyResolve; |
| 8948 | return responseFormData; |
| 8949 | } else if (/application\/x-www-form-urlencoded/.test(contentType)) { |
| 8950 | let entries; |
| 8951 | try { |
| 8952 | let text = ""; |
| 8953 | const streamingDecoder = new TextDecoder("utf-8", { ignoreBOM: true }); |
| 8954 | for await (const chunk of consumeBody(this[kState].body)) { |
| 8955 | if (!isUint8Array(chunk)) { |
| 8956 | throw new TypeError("Expected Uint8Array chunk"); |
| 8957 | } |
| 8958 | text += streamingDecoder.decode(chunk, { stream: true }); |
| 8959 | } |
| 8960 | text += streamingDecoder.decode(); |
| 8961 | entries = new URLSearchParams(text); |
| 8962 | } catch (err) { |
| 8963 | throw Object.assign(new TypeError(), { cause: err }); |
| 8964 | } |
| 8965 | const formData = new FormData(); |
| 8966 | for (const [name, value] of entries) { |
| 8967 | formData.append(name, value); |
| 8968 | } |
| 8969 | return formData; |
| 8970 | } else { |
| 8971 | await Promise.resolve(); |
| 8972 | throwIfAborted(this[kState]); |
| 8973 | throw webidl.errors.exception({ |
| 8974 | header: `${instance.name}.formData`, |
| 8975 | message: "Could not parse content as FormData." |
| 8976 | }); |
| 8977 | } |
| 8978 | } |
| 8979 | }; |
| 8980 | return methods; |
| 8981 | } |
| 8982 | function mixinBody(prototype) { |
| 8983 | Object.assign(prototype.prototype, bodyMixinMethods(prototype)); |
| 8984 | } |
| 8985 | async function specConsumeBody(object, convertBytesToJSValue, instance) { |
| 8986 | webidl.brandCheck(object, instance); |
| 8987 | throwIfAborted(object[kState]); |
| 8988 | if (bodyUnusable(object[kState].body)) { |
| 8989 | throw new TypeError("Body is unusable"); |
| 8990 | } |
| 8991 | const promise = createDeferredPromise(); |
| 8992 | const errorSteps = (error) => promise.reject(error); |
| 8993 | const successSteps = (data) => { |
| 8994 | try { |
| 8995 | promise.resolve(convertBytesToJSValue(data)); |
| 8996 | } catch (e) { |
| 8997 | errorSteps(e); |
| 8998 | } |
| 8999 | }; |
| 9000 | if (object[kState].body == null) { |
| 9001 | successSteps(new Uint8Array()); |
| 9002 | return promise.promise; |
| 9003 | } |
| 9004 | await fullyReadBody(object[kState].body, successSteps, errorSteps); |
| 9005 | return promise.promise; |
| 9006 | } |
| 9007 | function bodyUnusable(body) { |
| 9008 | return body != null && (body.stream.locked || util.isDisturbed(body.stream)); |
| 9009 | } |
| 9010 | function utf8DecodeBytes(buffer) { |
| 9011 | if (buffer.length === 0) { |
| 9012 | return ""; |
| 9013 | } |
| 9014 | if (buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191) { |
| 9015 | buffer = buffer.subarray(3); |
| 9016 | } |
| 9017 | const output = textDecoder.decode(buffer); |
| 9018 | return output; |
| 9019 | } |
| 9020 | function parseJSONFromBytes(bytes) { |
| 9021 | return JSON.parse(utf8DecodeBytes(bytes)); |
| 9022 | } |
| 9023 | function bodyMimeType(object) { |
| 9024 | const { headersList } = object[kState]; |
| 9025 | const contentType = headersList.get("content-type"); |
| 9026 | if (contentType === null) { |
| 9027 | return "failure"; |
| 9028 | } |
| 9029 | return parseMIMEType(contentType); |
| 9030 | } |
| 9031 | module2.exports = { |
| 9032 | extractBody, |
| 9033 | safelyExtractBody, |
| 9034 | cloneBody, |
| 9035 | mixinBody |
| 9036 | }; |
| 9037 | } |
| 9038 | }); |
| 9039 | |
| 9040 | // node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/core/request.js |
| 9041 | var require_request = __commonJS({ |
| 9042 | "node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/core/request.js"(exports2, module2) { |
| 9043 | "use strict"; |
| 9044 | var { |
| 9045 | InvalidArgumentError: InvalidArgumentError2, |
| 9046 | NotSupportedError |
| 9047 | } = require_errors(); |
| 9048 | var assert = require("assert"); |
| 9049 | var { kHTTP2BuildRequest, kHTTP2CopyHeaders, kHTTP1BuildRequest } = require_symbols(); |
| 9050 | var util = require_util(); |
| 9051 | var tokenRegExp = /^[\^_`a-zA-Z\-0-9!#$%&'*+.|~]+$/; |
| 9052 | var headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/; |
| 9053 | var invalidPathRegex = /[^\u0021-\u00ff]/; |
| 9054 | var kHandler = Symbol("handler"); |
| 9055 | var channels = {}; |
| 9056 | var extractBody; |
| 9057 | try { |
| 9058 | const diagnosticsChannel = require("diagnostics_channel"); |
| 9059 | channels.create = diagnosticsChannel.channel("undici:request:create"); |
| 9060 | channels.bodySent = diagnosticsChannel.channel("undici:request:bodySent"); |
| 9061 | channels.headers = diagnosticsChannel.channel("undici:request:headers"); |
| 9062 | channels.trailers = diagnosticsChannel.channel("undici:request:trailers"); |
| 9063 | channels.error = diagnosticsChannel.channel("undici:request:error"); |
| 9064 | } catch { |
| 9065 | channels.create = { hasSubscribers: false }; |
| 9066 | channels.bodySent = { hasSubscribers: false }; |
| 9067 | channels.headers = { hasSubscribers: false }; |
| 9068 | channels.trailers = { hasSubscribers: false }; |
| 9069 | channels.error = { hasSubscribers: false }; |
| 9070 | } |
| 9071 | var Request = class _Request { |
| 9072 | constructor(origin, { |
| 9073 | path: path5, |
| 9074 | method, |
| 9075 | body, |
| 9076 | headers, |
| 9077 | query, |
| 9078 | idempotent, |
| 9079 | blocking, |
| 9080 | upgrade, |
| 9081 | headersTimeout, |
| 9082 | bodyTimeout, |
| 9083 | reset, |
| 9084 | throwOnError, |
| 9085 | expectContinue |
| 9086 | }, handler2) { |
| 9087 | if (typeof path5 !== "string") { |
| 9088 | throw new InvalidArgumentError2("path must be a string"); |
| 9089 | } else if (path5[0] !== "/" && !(path5.startsWith("http://") || path5.startsWith("https://")) && method !== "CONNECT") { |
| 9090 | throw new InvalidArgumentError2("path must be an absolute URL or start with a slash"); |
| 9091 | } else if (invalidPathRegex.exec(path5) !== null) { |
| 9092 | throw new InvalidArgumentError2("invalid request path"); |
| 9093 | } |
| 9094 | if (typeof method !== "string") { |
| 9095 | throw new InvalidArgumentError2("method must be a string"); |
| 9096 | } else if (tokenRegExp.exec(method) === null) { |
| 9097 | throw new InvalidArgumentError2("invalid request method"); |
| 9098 | } |
| 9099 | if (upgrade && typeof upgrade !== "string") { |
| 9100 | throw new InvalidArgumentError2("upgrade must be a string"); |
| 9101 | } |
| 9102 | if (headersTimeout != null && (!Number.isFinite(headersTimeout) || headersTimeout < 0)) { |
| 9103 | throw new InvalidArgumentError2("invalid headersTimeout"); |
| 9104 | } |
| 9105 | if (bodyTimeout != null && (!Number.isFinite(bodyTimeout) || bodyTimeout < 0)) { |
| 9106 | throw new InvalidArgumentError2("invalid bodyTimeout"); |
| 9107 | } |
| 9108 | if (reset != null && typeof reset !== "boolean") { |
| 9109 | throw new InvalidArgumentError2("invalid reset"); |
| 9110 | } |
| 9111 | if (expectContinue != null && typeof expectContinue !== "boolean") { |
| 9112 | throw new InvalidArgumentError2("invalid expectContinue"); |
| 9113 | } |
| 9114 | this.headersTimeout = headersTimeout; |
| 9115 | this.bodyTimeout = bodyTimeout; |
| 9116 | this.throwOnError = throwOnError === true; |
| 9117 | this.method = method; |
| 9118 | this.abort = null; |
| 9119 | if (body == null) { |
| 9120 | this.body = null; |
| 9121 | } else if (util.isStream(body)) { |
| 9122 | this.body = body; |
| 9123 | const rState = this.body._readableState; |
| 9124 | if (!rState || !rState.autoDestroy) { |
| 9125 | this.endHandler = function autoDestroy() { |
| 9126 | util.destroy(this); |
| 9127 | }; |
| 9128 | this.body.on("end", this.endHandler); |
| 9129 | } |
| 9130 | this.errorHandler = (err) => { |
| 9131 | if (this.abort) { |
| 9132 | this.abort(err); |
| 9133 | } else { |
| 9134 | this.error = err; |
| 9135 | } |
| 9136 | }; |
| 9137 | this.body.on("error", this.errorHandler); |
| 9138 | } else if (util.isBuffer(body)) { |
| 9139 | this.body = body.byteLength ? body : null; |
| 9140 | } else if (ArrayBuffer.isView(body)) { |
| 9141 | this.body = body.buffer.byteLength ? Buffer.from(body.buffer, body.byteOffset, body.byteLength) : null; |
| 9142 | } else if (body instanceof ArrayBuffer) { |
| 9143 | this.body = body.byteLength ? Buffer.from(body) : null; |
| 9144 | } else if (typeof body === "string") { |
| 9145 | this.body = body.length ? Buffer.from(body) : null; |
| 9146 | } else if (util.isFormDataLike(body) || util.isIterable(body) || util.isBlobLike(body)) { |
| 9147 | this.body = body; |
| 9148 | } else { |
| 9149 | throw new InvalidArgumentError2("body must be a string, a Buffer, a Readable stream, an iterable, or an async iterable"); |
| 9150 | } |
| 9151 | this.completed = false; |
| 9152 | this.aborted = false; |
| 9153 | this.upgrade = upgrade || null; |
| 9154 | this.path = query ? util.buildURL(path5, query) : path5; |
| 9155 | this.origin = origin; |
| 9156 | this.idempotent = idempotent == null ? method === "HEAD" || method === "GET" : idempotent; |
| 9157 | this.blocking = blocking == null ? false : blocking; |
| 9158 | this.reset = reset == null ? null : reset; |
| 9159 | this.host = null; |
| 9160 | this.contentLength = null; |
| 9161 | this.contentType = null; |
| 9162 | this.headers = ""; |
| 9163 | this.expectContinue = expectContinue != null ? expectContinue : false; |
| 9164 | if (Array.isArray(headers)) { |
| 9165 | if (headers.length % 2 !== 0) { |
| 9166 | throw new InvalidArgumentError2("headers array must be even"); |
| 9167 | } |
| 9168 | for (let i = 0; i < headers.length; i += 2) { |
| 9169 | processHeader(this, headers[i], headers[i + 1]); |
| 9170 | } |
| 9171 | } else if (headers && typeof headers === "object") { |
| 9172 | const keys = Object.keys(headers); |
| 9173 | for (let i = 0; i < keys.length; i++) { |
| 9174 | const key = keys[i]; |
| 9175 | processHeader(this, key, headers[key]); |
| 9176 | } |
| 9177 | } else if (headers != null) { |
| 9178 | throw new InvalidArgumentError2("headers must be an object or an array"); |
| 9179 | } |
| 9180 | if (util.isFormDataLike(this.body)) { |
| 9181 | if (util.nodeMajor < 16 || util.nodeMajor === 16 && util.nodeMinor < 8) { |
| 9182 | throw new InvalidArgumentError2("Form-Data bodies are only supported in node v16.8 and newer."); |
| 9183 | } |
| 9184 | if (!extractBody) { |
| 9185 | extractBody = require_body().extractBody; |
| 9186 | } |
| 9187 | const [bodyStream, contentType] = extractBody(body); |
| 9188 | if (this.contentType == null) { |
| 9189 | this.contentType = contentType; |
| 9190 | this.headers += `content-type: ${contentType}\r |
| 9191 | `; |
| 9192 | } |
| 9193 | this.body = bodyStream.stream; |
| 9194 | this.contentLength = bodyStream.length; |
| 9195 | } else if (util.isBlobLike(body) && this.contentType == null && body.type) { |
| 9196 | this.contentType = body.type; |
| 9197 | this.headers += `content-type: ${body.type}\r |
| 9198 | `; |
| 9199 | } |
| 9200 | util.validateHandler(handler2, method, upgrade); |
| 9201 | this.servername = util.getServerName(this.host); |
| 9202 | this[kHandler] = handler2; |
| 9203 | if (channels.create.hasSubscribers) { |
| 9204 | channels.create.publish({ request: this }); |
| 9205 | } |
| 9206 | } |
| 9207 | onBodySent(chunk) { |
| 9208 | if (this[kHandler].onBodySent) { |
| 9209 | try { |
| 9210 | return this[kHandler].onBodySent(chunk); |
| 9211 | } catch (err) { |
| 9212 | this.abort(err); |
| 9213 | } |
| 9214 | } |
| 9215 | } |
| 9216 | onRequestSent() { |
| 9217 | if (channels.bodySent.hasSubscribers) { |
| 9218 | channels.bodySent.publish({ request: this }); |
| 9219 | } |
| 9220 | if (this[kHandler].onRequestSent) { |
| 9221 | try { |
| 9222 | return this[kHandler].onRequestSent(); |
| 9223 | } catch (err) { |
| 9224 | this.abort(err); |
| 9225 | } |
| 9226 | } |
| 9227 | } |
| 9228 | onConnect(abort) { |
| 9229 | assert(!this.aborted); |
| 9230 | assert(!this.completed); |
| 9231 | if (this.error) { |
| 9232 | abort(this.error); |
| 9233 | } else { |
| 9234 | this.abort = abort; |
| 9235 | return this[kHandler].onConnect(abort); |
| 9236 | } |
| 9237 | } |
| 9238 | onHeaders(statusCode, headers, resume, statusText) { |
| 9239 | assert(!this.aborted); |
| 9240 | assert(!this.completed); |
| 9241 | if (channels.headers.hasSubscribers) { |
| 9242 | channels.headers.publish({ request: this, response: { statusCode, headers, statusText } }); |
| 9243 | } |
| 9244 | try { |
| 9245 | return this[kHandler].onHeaders(statusCode, headers, resume, statusText); |
| 9246 | } catch (err) { |
| 9247 | this.abort(err); |
| 9248 | } |
| 9249 | } |
| 9250 | onData(chunk) { |
| 9251 | assert(!this.aborted); |
| 9252 | assert(!this.completed); |
| 9253 | try { |
| 9254 | return this[kHandler].onData(chunk); |
| 9255 | } catch (err) { |
| 9256 | this.abort(err); |
| 9257 | return false; |
| 9258 | } |
| 9259 | } |
| 9260 | onUpgrade(statusCode, headers, socket) { |
| 9261 | assert(!this.aborted); |
| 9262 | assert(!this.completed); |
| 9263 | return this[kHandler].onUpgrade(statusCode, headers, socket); |
| 9264 | } |
| 9265 | onComplete(trailers) { |
| 9266 | this.onFinally(); |
| 9267 | assert(!this.aborted); |
| 9268 | this.completed = true; |
| 9269 | if (channels.trailers.hasSubscribers) { |
| 9270 | channels.trailers.publish({ request: this, trailers }); |
| 9271 | } |
| 9272 | try { |
| 9273 | return this[kHandler].onComplete(trailers); |
| 9274 | } catch (err) { |
| 9275 | this.onError(err); |
| 9276 | } |
| 9277 | } |
| 9278 | onError(error) { |
| 9279 | this.onFinally(); |
| 9280 | if (channels.error.hasSubscribers) { |
| 9281 | channels.error.publish({ request: this, error }); |
| 9282 | } |
| 9283 | if (this.aborted) { |
| 9284 | return; |
| 9285 | } |
| 9286 | this.aborted = true; |
| 9287 | return this[kHandler].onError(error); |
| 9288 | } |
| 9289 | onFinally() { |
| 9290 | if (this.errorHandler) { |
| 9291 | this.body.off("error", this.errorHandler); |
| 9292 | this.errorHandler = null; |
| 9293 | } |
| 9294 | if (this.endHandler) { |
| 9295 | this.body.off("end", this.endHandler); |
| 9296 | this.endHandler = null; |
| 9297 | } |
| 9298 | } |
| 9299 | // TODO: adjust to support H2 |
| 9300 | addHeader(key, value) { |
| 9301 | processHeader(this, key, value); |
| 9302 | return this; |
| 9303 | } |
| 9304 | static [kHTTP1BuildRequest](origin, opts, handler2) { |
| 9305 | return new _Request(origin, opts, handler2); |
| 9306 | } |
| 9307 | static [kHTTP2BuildRequest](origin, opts, handler2) { |
| 9308 | const headers = opts.headers; |
| 9309 | opts = { ...opts, headers: null }; |
| 9310 | const request2 = new _Request(origin, opts, handler2); |
| 9311 | request2.headers = {}; |
| 9312 | if (Array.isArray(headers)) { |
| 9313 | if (headers.length % 2 !== 0) { |
| 9314 | throw new InvalidArgumentError2("headers array must be even"); |
| 9315 | } |
| 9316 | for (let i = 0; i < headers.length; i += 2) { |
| 9317 | processHeader(request2, headers[i], headers[i + 1], true); |
| 9318 | } |
| 9319 | } else if (headers && typeof headers === "object") { |
| 9320 | const keys = Object.keys(headers); |
| 9321 | for (let i = 0; i < keys.length; i++) { |
| 9322 | const key = keys[i]; |
| 9323 | processHeader(request2, key, headers[key], true); |
| 9324 | } |
| 9325 | } else if (headers != null) { |
| 9326 | throw new InvalidArgumentError2("headers must be an object or an array"); |
| 9327 | } |
| 9328 | return request2; |
| 9329 | } |
| 9330 | static [kHTTP2CopyHeaders](raw) { |
| 9331 | const rawHeaders = raw.split("\r\n"); |
| 9332 | const headers = {}; |
| 9333 | for (const header of rawHeaders) { |
| 9334 | const [key, value] = header.split(": "); |
| 9335 | if (value == null || value.length === 0) continue; |
| 9336 | if (headers[key]) headers[key] += `,${value}`; |
| 9337 | else headers[key] = value; |
| 9338 | } |
| 9339 | return headers; |
| 9340 | } |
| 9341 | }; |
| 9342 | function processHeaderValue(key, val, skipAppend) { |
| 9343 | if (val && typeof val === "object") { |
| 9344 | throw new InvalidArgumentError2(`invalid ${key} header`); |
| 9345 | } |
| 9346 | val = val != null ? `${val}` : ""; |
| 9347 | if (headerCharRegex.exec(val) !== null) { |
| 9348 | throw new InvalidArgumentError2(`invalid ${key} header`); |
| 9349 | } |
| 9350 | return skipAppend ? val : `${key}: ${val}\r |
| 9351 | `; |
| 9352 | } |
| 9353 | function processHeader(request2, key, val, skipAppend = false) { |
| 9354 | if (val && (typeof val === "object" && !Array.isArray(val))) { |
| 9355 | throw new InvalidArgumentError2(`invalid ${key} header`); |
| 9356 | } else if (val === void 0) { |
| 9357 | return; |
| 9358 | } |
| 9359 | if (request2.host === null && key.length === 4 && key.toLowerCase() === "host") { |
| 9360 | if (headerCharRegex.exec(val) !== null) { |
| 9361 | throw new InvalidArgumentError2(`invalid ${key} header`); |
| 9362 | } |
| 9363 | request2.host = val; |
| 9364 | } else if (request2.contentLength === null && key.length === 14 && key.toLowerCase() === "content-length") { |
| 9365 | request2.contentLength = parseInt(val, 10); |
| 9366 | if (!Number.isFinite(request2.contentLength)) { |
| 9367 | throw new InvalidArgumentError2("invalid content-length header"); |
| 9368 | } |
| 9369 | } else if (request2.contentType === null && key.length === 12 && key.toLowerCase() === "content-type") { |
| 9370 | request2.contentType = val; |
| 9371 | if (skipAppend) request2.headers[key] = processHeaderValue(key, val, skipAppend); |
| 9372 | else request2.headers += processHeaderValue(key, val); |
| 9373 | } else if (key.length === 17 && key.toLowerCase() === "transfer-encoding") { |
| 9374 | throw new InvalidArgumentError2("invalid transfer-encoding header"); |
| 9375 | } else if (key.length === 10 && key.toLowerCase() === "connection") { |
| 9376 | const value = typeof val === "string" ? val.toLowerCase() : null; |
| 9377 | if (value !== "close" && value !== "keep-alive") { |
| 9378 | throw new InvalidArgumentError2("invalid connection header"); |
| 9379 | } else if (value === "close") { |
| 9380 | request2.reset = true; |
| 9381 | } |
| 9382 | } else if (key.length === 10 && key.toLowerCase() === "keep-alive") { |
| 9383 | throw new InvalidArgumentError2("invalid keep-alive header"); |
| 9384 | } else if (key.length === 7 && key.toLowerCase() === "upgrade") { |
| 9385 | throw new InvalidArgumentError2("invalid upgrade header"); |
| 9386 | } else if (key.length === 6 && key.toLowerCase() === "expect") { |
| 9387 | throw new NotSupportedError("expect header not supported"); |
| 9388 | } else if (tokenRegExp.exec(key) === null) { |
| 9389 | throw new InvalidArgumentError2("invalid header key"); |
| 9390 | } else { |
| 9391 | if (Array.isArray(val)) { |
| 9392 | for (let i = 0; i < val.length; i++) { |
| 9393 | if (skipAppend) { |
| 9394 | if (request2.headers[key]) request2.headers[key] += `,${processHeaderValue(key, val[i], skipAppend)}`; |
| 9395 | else request2.headers[key] = processHeaderValue(key, val[i], skipAppend); |
| 9396 | } else { |
| 9397 | request2.headers += processHeaderValue(key, val[i]); |
| 9398 | } |
| 9399 | } |
| 9400 | } else { |
| 9401 | if (skipAppend) request2.headers[key] = processHeaderValue(key, val, skipAppend); |
| 9402 | else request2.headers += processHeaderValue(key, val); |
| 9403 | } |
| 9404 | } |
| 9405 | } |
| 9406 | module2.exports = Request; |
| 9407 | } |
| 9408 | }); |
| 9409 | |
| 9410 | // node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/dispatcher.js |
| 9411 | var require_dispatcher = __commonJS({ |
| 9412 | "node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/dispatcher.js"(exports2, module2) { |
| 9413 | "use strict"; |
| 9414 | var EventEmitter = require("events"); |
| 9415 | var Dispatcher = class extends EventEmitter { |
| 9416 | dispatch() { |
| 9417 | throw new Error("not implemented"); |
| 9418 | } |
| 9419 | close() { |
| 9420 | throw new Error("not implemented"); |
| 9421 | } |
| 9422 | destroy() { |
| 9423 | throw new Error("not implemented"); |
| 9424 | } |
| 9425 | }; |
| 9426 | module2.exports = Dispatcher; |
| 9427 | } |
| 9428 | }); |
| 9429 | |
| 9430 | // node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/dispatcher-base.js |
| 9431 | var require_dispatcher_base = __commonJS({ |
| 9432 | "node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/dispatcher-base.js"(exports2, module2) { |
| 9433 | "use strict"; |
| 9434 | var Dispatcher = require_dispatcher(); |
| 9435 | var { |
| 9436 | ClientDestroyedError, |
| 9437 | ClientClosedError, |
| 9438 | InvalidArgumentError: InvalidArgumentError2 |
| 9439 | } = require_errors(); |
| 9440 | var { kDestroy, kClose, kDispatch, kInterceptors } = require_symbols(); |
| 9441 | var kDestroyed = Symbol("destroyed"); |
| 9442 | var kClosed = Symbol("closed"); |
| 9443 | var kOnDestroyed = Symbol("onDestroyed"); |
| 9444 | var kOnClosed = Symbol("onClosed"); |
| 9445 | var kInterceptedDispatch = Symbol("Intercepted Dispatch"); |
| 9446 | var DispatcherBase = class extends Dispatcher { |
| 9447 | constructor() { |
| 9448 | super(); |
| 9449 | this[kDestroyed] = false; |
| 9450 | this[kOnDestroyed] = null; |
| 9451 | this[kClosed] = false; |
| 9452 | this[kOnClosed] = []; |
| 9453 | } |
| 9454 | get destroyed() { |
| 9455 | return this[kDestroyed]; |
| 9456 | } |
| 9457 | get closed() { |
| 9458 | return this[kClosed]; |
| 9459 | } |
| 9460 | get interceptors() { |
| 9461 | return this[kInterceptors]; |
| 9462 | } |
| 9463 | set interceptors(newInterceptors) { |
| 9464 | if (newInterceptors) { |
| 9465 | for (let i = newInterceptors.length - 1; i >= 0; i--) { |
| 9466 | const interceptor = this[kInterceptors][i]; |
| 9467 | if (typeof interceptor !== "function") { |
| 9468 | throw new InvalidArgumentError2("interceptor must be an function"); |
| 9469 | } |
| 9470 | } |
| 9471 | } |
| 9472 | this[kInterceptors] = newInterceptors; |
| 9473 | } |
| 9474 | close(callback) { |
| 9475 | if (callback === void 0) { |
| 9476 | return new Promise((resolve, reject) => { |
| 9477 | this.close((err, data) => { |
| 9478 | return err ? reject(err) : resolve(data); |
| 9479 | }); |
| 9480 | }); |
| 9481 | } |
| 9482 | if (typeof callback !== "function") { |
| 9483 | throw new InvalidArgumentError2("invalid callback"); |
| 9484 | } |
| 9485 | if (this[kDestroyed]) { |
| 9486 | queueMicrotask(() => callback(new ClientDestroyedError(), null)); |
| 9487 | return; |
| 9488 | } |
| 9489 | if (this[kClosed]) { |
| 9490 | if (this[kOnClosed]) { |
| 9491 | this[kOnClosed].push(callback); |
| 9492 | } else { |
| 9493 | queueMicrotask(() => callback(null, null)); |
| 9494 | } |
| 9495 | return; |
| 9496 | } |
| 9497 | this[kClosed] = true; |
| 9498 | this[kOnClosed].push(callback); |
| 9499 | const onClosed = () => { |
| 9500 | const callbacks = this[kOnClosed]; |
| 9501 | this[kOnClosed] = null; |
| 9502 | for (let i = 0; i < callbacks.length; i++) { |
| 9503 | callbacks[i](null, null); |
| 9504 | } |
| 9505 | }; |
| 9506 | this[kClose]().then(() => this.destroy()).then(() => { |
| 9507 | queueMicrotask(onClosed); |
| 9508 | }); |
| 9509 | } |
| 9510 | destroy(err, callback) { |
| 9511 | if (typeof err === "function") { |
| 9512 | callback = err; |
| 9513 | err = null; |
| 9514 | } |
| 9515 | if (callback === void 0) { |
| 9516 | return new Promise((resolve, reject) => { |
| 9517 | this.destroy(err, (err2, data) => { |
| 9518 | return err2 ? ( |
| 9519 | /* istanbul ignore next: should never error */ |
| 9520 | reject(err2) |
| 9521 | ) : resolve(data); |
| 9522 | }); |
| 9523 | }); |
| 9524 | } |
| 9525 | if (typeof callback !== "function") { |
| 9526 | throw new InvalidArgumentError2("invalid callback"); |
| 9527 | } |
| 9528 | if (this[kDestroyed]) { |
| 9529 | if (this[kOnDestroyed]) { |
| 9530 | this[kOnDestroyed].push(callback); |
| 9531 | } else { |
| 9532 | queueMicrotask(() => callback(null, null)); |
| 9533 | } |
| 9534 | return; |
| 9535 | } |
| 9536 | if (!err) { |
| 9537 | err = new ClientDestroyedError(); |
| 9538 | } |
| 9539 | this[kDestroyed] = true; |
| 9540 | this[kOnDestroyed] = this[kOnDestroyed] || []; |
| 9541 | this[kOnDestroyed].push(callback); |
| 9542 | const onDestroyed = () => { |
| 9543 | const callbacks = this[kOnDestroyed]; |
| 9544 | this[kOnDestroyed] = null; |
| 9545 | for (let i = 0; i < callbacks.length; i++) { |
| 9546 | callbacks[i](null, null); |
| 9547 | } |
| 9548 | }; |
| 9549 | this[kDestroy](err).then(() => { |
| 9550 | queueMicrotask(onDestroyed); |
| 9551 | }); |
| 9552 | } |
| 9553 | [kInterceptedDispatch](opts, handler2) { |
| 9554 | if (!this[kInterceptors] || this[kInterceptors].length === 0) { |
| 9555 | this[kInterceptedDispatch] = this[kDispatch]; |
| 9556 | return this[kDispatch](opts, handler2); |
| 9557 | } |
| 9558 | let dispatch = this[kDispatch].bind(this); |
| 9559 | for (let i = this[kInterceptors].length - 1; i >= 0; i--) { |
| 9560 | dispatch = this[kInterceptors][i](dispatch); |
| 9561 | } |
| 9562 | this[kInterceptedDispatch] = dispatch; |
| 9563 | return dispatch(opts, handler2); |
| 9564 | } |
| 9565 | dispatch(opts, handler2) { |
| 9566 | if (!handler2 || typeof handler2 !== "object") { |
| 9567 | throw new InvalidArgumentError2("handler must be an object"); |
| 9568 | } |
| 9569 | try { |
| 9570 | if (!opts || typeof opts !== "object") { |
| 9571 | throw new InvalidArgumentError2("opts must be an object."); |
| 9572 | } |
| 9573 | if (this[kDestroyed] || this[kOnDestroyed]) { |
| 9574 | throw new ClientDestroyedError(); |
| 9575 | } |
| 9576 | if (this[kClosed]) { |
| 9577 | throw new ClientClosedError(); |
| 9578 | } |
| 9579 | return this[kInterceptedDispatch](opts, handler2); |
| 9580 | } catch (err) { |
| 9581 | if (typeof handler2.onError !== "function") { |
| 9582 | throw new InvalidArgumentError2("invalid onError method"); |
| 9583 | } |
| 9584 | handler2.onError(err); |
| 9585 | return false; |
| 9586 | } |
| 9587 | } |
| 9588 | }; |
| 9589 | module2.exports = DispatcherBase; |
| 9590 | } |
| 9591 | }); |
| 9592 | |
| 9593 | // node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/core/connect.js |
| 9594 | var require_connect = __commonJS({ |
| 9595 | "node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/core/connect.js"(exports2, module2) { |
| 9596 | "use strict"; |
| 9597 | var net = require("net"); |
| 9598 | var assert = require("assert"); |
| 9599 | var util = require_util(); |
| 9600 | var { InvalidArgumentError: InvalidArgumentError2, ConnectTimeoutError } = require_errors(); |
| 9601 | var tls; |
| 9602 | var SessionCache; |
| 9603 | if (global.FinalizationRegistry && !process.env.NODE_V8_COVERAGE) { |
| 9604 | SessionCache = class WeakSessionCache { |
| 9605 | constructor(maxCachedSessions) { |
| 9606 | this._maxCachedSessions = maxCachedSessions; |
| 9607 | this._sessionCache = /* @__PURE__ */ new Map(); |
| 9608 | this._sessionRegistry = new global.FinalizationRegistry((key) => { |
| 9609 | if (this._sessionCache.size < this._maxCachedSessions) { |
| 9610 | return; |
| 9611 | } |
| 9612 | const ref = this._sessionCache.get(key); |
| 9613 | if (ref !== void 0 && ref.deref() === void 0) { |
| 9614 | this._sessionCache.delete(key); |
| 9615 | } |
| 9616 | }); |
| 9617 | } |
| 9618 | get(sessionKey) { |
| 9619 | const ref = this._sessionCache.get(sessionKey); |
| 9620 | return ref ? ref.deref() : null; |
| 9621 | } |
| 9622 | set(sessionKey, session) { |
| 9623 | if (this._maxCachedSessions === 0) { |
| 9624 | return; |
| 9625 | } |
| 9626 | this._sessionCache.set(sessionKey, new WeakRef(session)); |
| 9627 | this._sessionRegistry.register(session, sessionKey); |
| 9628 | } |
| 9629 | }; |
| 9630 | } else { |
| 9631 | SessionCache = class SimpleSessionCache { |
| 9632 | constructor(maxCachedSessions) { |
| 9633 | this._maxCachedSessions = maxCachedSessions; |
| 9634 | this._sessionCache = /* @__PURE__ */ new Map(); |
| 9635 | } |
| 9636 | get(sessionKey) { |
| 9637 | return this._sessionCache.get(sessionKey); |
| 9638 | } |
| 9639 | set(sessionKey, session) { |
| 9640 | if (this._maxCachedSessions === 0) { |
| 9641 | return; |
| 9642 | } |
| 9643 | if (this._sessionCache.size >= this._maxCachedSessions) { |
| 9644 | const { value: oldestKey } = this._sessionCache.keys().next(); |
| 9645 | this._sessionCache.delete(oldestKey); |
| 9646 | } |
| 9647 | this._sessionCache.set(sessionKey, session); |
| 9648 | } |
| 9649 | }; |
| 9650 | } |
| 9651 | function buildConnector({ allowH2, maxCachedSessions, socketPath, timeout, ...opts }) { |
| 9652 | if (maxCachedSessions != null && (!Number.isInteger(maxCachedSessions) || maxCachedSessions < 0)) { |
| 9653 | throw new InvalidArgumentError2("maxCachedSessions must be a positive integer or zero"); |
| 9654 | } |
| 9655 | const options = { path: socketPath, ...opts }; |
| 9656 | const sessionCache = new SessionCache(maxCachedSessions == null ? 100 : maxCachedSessions); |
| 9657 | timeout = timeout == null ? 1e4 : timeout; |
| 9658 | allowH2 = allowH2 != null ? allowH2 : false; |
| 9659 | return function connect({ hostname, host, protocol, port, servername, localAddress, httpSocket }, callback) { |
| 9660 | let socket; |
| 9661 | if (protocol === "https:") { |
| 9662 | if (!tls) { |
| 9663 | tls = require("tls"); |
| 9664 | } |
| 9665 | servername = servername || options.servername || util.getServerName(host) || null; |
| 9666 | const sessionKey = servername || hostname; |
| 9667 | const session = sessionCache.get(sessionKey) || null; |
| 9668 | assert(sessionKey); |
| 9669 | socket = tls.connect({ |
| 9670 | highWaterMark: 16384, |
| 9671 | // TLS in node can't have bigger HWM anyway... |
| 9672 | ...options, |
| 9673 | servername, |
| 9674 | session, |
| 9675 | localAddress, |
| 9676 | // TODO(HTTP/2): Add support for h2c |
| 9677 | ALPNProtocols: allowH2 ? ["http/1.1", "h2"] : ["http/1.1"], |
| 9678 | socket: httpSocket, |
| 9679 | // upgrade socket connection |
| 9680 | port: port || 443, |
| 9681 | host: hostname |
| 9682 | }); |
| 9683 | socket.on("session", function(session2) { |
| 9684 | sessionCache.set(sessionKey, session2); |
| 9685 | }); |
| 9686 | } else { |
| 9687 | assert(!httpSocket, "httpSocket can only be sent on TLS update"); |
| 9688 | socket = net.connect({ |
| 9689 | highWaterMark: 64 * 1024, |
| 9690 | // Same as nodejs fs streams. |
| 9691 | ...options, |
| 9692 | localAddress, |
| 9693 | port: port || 80, |
| 9694 | host: hostname |
| 9695 | }); |
| 9696 | } |
| 9697 | if (options.keepAlive == null || options.keepAlive) { |
| 9698 | const keepAliveInitialDelay = options.keepAliveInitialDelay === void 0 ? 6e4 : options.keepAliveInitialDelay; |
| 9699 | socket.setKeepAlive(true, keepAliveInitialDelay); |
| 9700 | } |
| 9701 | const cancelTimeout = setupTimeout(() => onConnectTimeout(socket), timeout); |
| 9702 | socket.setNoDelay(true).once(protocol === "https:" ? "secureConnect" : "connect", function() { |
| 9703 | cancelTimeout(); |
| 9704 | if (callback) { |
| 9705 | const cb = callback; |
| 9706 | callback = null; |
| 9707 | cb(null, this); |
| 9708 | } |
| 9709 | }).on("error", function(err) { |
| 9710 | cancelTimeout(); |
| 9711 | if (callback) { |
| 9712 | const cb = callback; |
| 9713 | callback = null; |
| 9714 | cb(err); |
| 9715 | } |
| 9716 | }); |
| 9717 | return socket; |
| 9718 | }; |
| 9719 | } |
| 9720 | function setupTimeout(onConnectTimeout2, timeout) { |
| 9721 | if (!timeout) { |
| 9722 | return () => { |
| 9723 | }; |
| 9724 | } |
| 9725 | let s1 = null; |
| 9726 | let s2 = null; |
| 9727 | const timeoutId = setTimeout(() => { |
| 9728 | s1 = setImmediate(() => { |
| 9729 | if (process.platform === "win32") { |
| 9730 | s2 = setImmediate(() => onConnectTimeout2()); |
| 9731 | } else { |
| 9732 | onConnectTimeout2(); |
| 9733 | } |
| 9734 | }); |
| 9735 | }, timeout); |
| 9736 | return () => { |
| 9737 | clearTimeout(timeoutId); |
| 9738 | clearImmediate(s1); |
| 9739 | clearImmediate(s2); |
| 9740 | }; |
| 9741 | } |
| 9742 | function onConnectTimeout(socket) { |
| 9743 | util.destroy(socket, new ConnectTimeoutError()); |
| 9744 | } |
| 9745 | module2.exports = buildConnector; |
| 9746 | } |
| 9747 | }); |
| 9748 | |
| 9749 | // node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/llhttp/utils.js |
| 9750 | var require_utils2 = __commonJS({ |
| 9751 | "node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/llhttp/utils.js"(exports2) { |
| 9752 | "use strict"; |
| 9753 | Object.defineProperty(exports2, "__esModule", { value: true }); |
| 9754 | exports2.enumToMap = void 0; |
| 9755 | function enumToMap(obj) { |
| 9756 | const res = {}; |
| 9757 | Object.keys(obj).forEach((key) => { |
| 9758 | const value = obj[key]; |
| 9759 | if (typeof value === "number") { |
| 9760 | res[key] = value; |
| 9761 | } |
| 9762 | }); |
| 9763 | return res; |
| 9764 | } |
| 9765 | exports2.enumToMap = enumToMap; |
| 9766 | } |
| 9767 | }); |
| 9768 | |
| 9769 | // node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/llhttp/constants.js |
| 9770 | var require_constants3 = __commonJS({ |
| 9771 | "node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/llhttp/constants.js"(exports2) { |
| 9772 | "use strict"; |
| 9773 | Object.defineProperty(exports2, "__esModule", { value: true }); |
| 9774 | exports2.SPECIAL_HEADERS = exports2.HEADER_STATE = exports2.MINOR = exports2.MAJOR = exports2.CONNECTION_TOKEN_CHARS = exports2.HEADER_CHARS = exports2.TOKEN = exports2.STRICT_TOKEN = exports2.HEX = exports2.URL_CHAR = exports2.STRICT_URL_CHAR = exports2.USERINFO_CHARS = exports2.MARK = exports2.ALPHANUM = exports2.NUM = exports2.HEX_MAP = exports2.NUM_MAP = exports2.ALPHA = exports2.FINISH = exports2.H_METHOD_MAP = exports2.METHOD_MAP = exports2.METHODS_RTSP = exports2.METHODS_ICE = exports2.METHODS_HTTP = exports2.METHODS = exports2.LENIENT_FLAGS = exports2.FLAGS = exports2.TYPE = exports2.ERROR = void 0; |
| 9775 | var utils_1 = require_utils2(); |
| 9776 | var ERROR; |
| 9777 | (function(ERROR2) { |
| 9778 | ERROR2[ERROR2["OK"] = 0] = "OK"; |
| 9779 | ERROR2[ERROR2["INTERNAL"] = 1] = "INTERNAL"; |
| 9780 | ERROR2[ERROR2["STRICT"] = 2] = "STRICT"; |
| 9781 | ERROR2[ERROR2["LF_EXPECTED"] = 3] = "LF_EXPECTED"; |
| 9782 | ERROR2[ERROR2["UNEXPECTED_CONTENT_LENGTH"] = 4] = "UNEXPECTED_CONTENT_LENGTH"; |
| 9783 | ERROR2[ERROR2["CLOSED_CONNECTION"] = 5] = "CLOSED_CONNECTION"; |
| 9784 | ERROR2[ERROR2["INVALID_METHOD"] = 6] = "INVALID_METHOD"; |
| 9785 | ERROR2[ERROR2["INVALID_URL"] = 7] = "INVALID_URL"; |
| 9786 | ERROR2[ERROR2["INVALID_CONSTANT"] = 8] = "INVALID_CONSTANT"; |
| 9787 | ERROR2[ERROR2["INVALID_VERSION"] = 9] = "INVALID_VERSION"; |
| 9788 | ERROR2[ERROR2["INVALID_HEADER_TOKEN"] = 10] = "INVALID_HEADER_TOKEN"; |
| 9789 | ERROR2[ERROR2["INVALID_CONTENT_LENGTH"] = 11] = "INVALID_CONTENT_LENGTH"; |
| 9790 | ERROR2[ERROR2["INVALID_CHUNK_SIZE"] = 12] = "INVALID_CHUNK_SIZE"; |
| 9791 | ERROR2[ERROR2["INVALID_STATUS"] = 13] = "INVALID_STATUS"; |
| 9792 | ERROR2[ERROR2["INVALID_EOF_STATE"] = 14] = "INVALID_EOF_STATE"; |
| 9793 | ERROR2[ERROR2["INVALID_TRANSFER_ENCODING"] = 15] = "INVALID_TRANSFER_ENCODING"; |
| 9794 | ERROR2[ERROR2["CB_MESSAGE_BEGIN"] = 16] = "CB_MESSAGE_BEGIN"; |
| 9795 | ERROR2[ERROR2["CB_HEADERS_COMPLETE"] = 17] = "CB_HEADERS_COMPLETE"; |
| 9796 | ERROR2[ERROR2["CB_MESSAGE_COMPLETE"] = 18] = "CB_MESSAGE_COMPLETE"; |
| 9797 | ERROR2[ERROR2["CB_CHUNK_HEADER"] = 19] = "CB_CHUNK_HEADER"; |
| 9798 | ERROR2[ERROR2["CB_CHUNK_COMPLETE"] = 20] = "CB_CHUNK_COMPLETE"; |
| 9799 | ERROR2[ERROR2["PAUSED"] = 21] = "PAUSED"; |
| 9800 | ERROR2[ERROR2["PAUSED_UPGRADE"] = 22] = "PAUSED_UPGRADE"; |
| 9801 | ERROR2[ERROR2["PAUSED_H2_UPGRADE"] = 23] = "PAUSED_H2_UPGRADE"; |
| 9802 | ERROR2[ERROR2["USER"] = 24] = "USER"; |
| 9803 | })(ERROR = exports2.ERROR || (exports2.ERROR = {})); |
| 9804 | var TYPE; |
| 9805 | (function(TYPE2) { |
| 9806 | TYPE2[TYPE2["BOTH"] = 0] = "BOTH"; |
| 9807 | TYPE2[TYPE2["REQUEST"] = 1] = "REQUEST"; |
| 9808 | TYPE2[TYPE2["RESPONSE"] = 2] = "RESPONSE"; |
| 9809 | })(TYPE = exports2.TYPE || (exports2.TYPE = {})); |
| 9810 | var FLAGS; |
| 9811 | (function(FLAGS2) { |
| 9812 | FLAGS2[FLAGS2["CONNECTION_KEEP_ALIVE"] = 1] = "CONNECTION_KEEP_ALIVE"; |
| 9813 | FLAGS2[FLAGS2["CONNECTION_CLOSE"] = 2] = "CONNECTION_CLOSE"; |
| 9814 | FLAGS2[FLAGS2["CONNECTION_UPGRADE"] = 4] = "CONNECTION_UPGRADE"; |
| 9815 | FLAGS2[FLAGS2["CHUNKED"] = 8] = "CHUNKED"; |
| 9816 | FLAGS2[FLAGS2["UPGRADE"] = 16] = "UPGRADE"; |
| 9817 | FLAGS2[FLAGS2["CONTENT_LENGTH"] = 32] = "CONTENT_LENGTH"; |
| 9818 | FLAGS2[FLAGS2["SKIPBODY"] = 64] = "SKIPBODY"; |
| 9819 | FLAGS2[FLAGS2["TRAILING"] = 128] = "TRAILING"; |
| 9820 | FLAGS2[FLAGS2["TRANSFER_ENCODING"] = 512] = "TRANSFER_ENCODING"; |
| 9821 | })(FLAGS = exports2.FLAGS || (exports2.FLAGS = {})); |
| 9822 | var LENIENT_FLAGS; |
| 9823 | (function(LENIENT_FLAGS2) { |
| 9824 | LENIENT_FLAGS2[LENIENT_FLAGS2["HEADERS"] = 1] = "HEADERS"; |
| 9825 | LENIENT_FLAGS2[LENIENT_FLAGS2["CHUNKED_LENGTH"] = 2] = "CHUNKED_LENGTH"; |
| 9826 | LENIENT_FLAGS2[LENIENT_FLAGS2["KEEP_ALIVE"] = 4] = "KEEP_ALIVE"; |
| 9827 | })(LENIENT_FLAGS = exports2.LENIENT_FLAGS || (exports2.LENIENT_FLAGS = {})); |
| 9828 | var METHODS; |
| 9829 | (function(METHODS2) { |
| 9830 | METHODS2[METHODS2["DELETE"] = 0] = "DELETE"; |
| 9831 | METHODS2[METHODS2["GET"] = 1] = "GET"; |
| 9832 | METHODS2[METHODS2["HEAD"] = 2] = "HEAD"; |
| 9833 | METHODS2[METHODS2["POST"] = 3] = "POST"; |
| 9834 | METHODS2[METHODS2["PUT"] = 4] = "PUT"; |
| 9835 | METHODS2[METHODS2["CONNECT"] = 5] = "CONNECT"; |
| 9836 | METHODS2[METHODS2["OPTIONS"] = 6] = "OPTIONS"; |
| 9837 | METHODS2[METHODS2["TRACE"] = 7] = "TRACE"; |
| 9838 | METHODS2[METHODS2["COPY"] = 8] = "COPY"; |
| 9839 | METHODS2[METHODS2["LOCK"] = 9] = "LOCK"; |
| 9840 | METHODS2[METHODS2["MKCOL"] = 10] = "MKCOL"; |
| 9841 | METHODS2[METHODS2["MOVE"] = 11] = "MOVE"; |
| 9842 | METHODS2[METHODS2["PROPFIND"] = 12] = "PROPFIND"; |
| 9843 | METHODS2[METHODS2["PROPPATCH"] = 13] = "PROPPATCH"; |
| 9844 | METHODS2[METHODS2["SEARCH"] = 14] = "SEARCH"; |
| 9845 | METHODS2[METHODS2["UNLOCK"] = 15] = "UNLOCK"; |
| 9846 | METHODS2[METHODS2["BIND"] = 16] = "BIND"; |
| 9847 | METHODS2[METHODS2["REBIND"] = 17] = "REBIND"; |
| 9848 | METHODS2[METHODS2["UNBIND"] = 18] = "UNBIND"; |
| 9849 | METHODS2[METHODS2["ACL"] = 19] = "ACL"; |
| 9850 | METHODS2[METHODS2["REPORT"] = 20] = "REPORT"; |
| 9851 | METHODS2[METHODS2["MKACTIVITY"] = 21] = "MKACTIVITY"; |
| 9852 | METHODS2[METHODS2["CHECKOUT"] = 22] = "CHECKOUT"; |
| 9853 | METHODS2[METHODS2["MERGE"] = 23] = "MERGE"; |
| 9854 | METHODS2[METHODS2["M-SEARCH"] = 24] = "M-SEARCH"; |
| 9855 | METHODS2[METHODS2["NOTIFY"] = 25] = "NOTIFY"; |
| 9856 | METHODS2[METHODS2["SUBSCRIBE"] = 26] = "SUBSCRIBE"; |
| 9857 | METHODS2[METHODS2["UNSUBSCRIBE"] = 27] = "UNSUBSCRIBE"; |
| 9858 | METHODS2[METHODS2["PATCH"] = 28] = "PATCH"; |
| 9859 | METHODS2[METHODS2["PURGE"] = 29] = "PURGE"; |
| 9860 | METHODS2[METHODS2["MKCALENDAR"] = 30] = "MKCALENDAR"; |
| 9861 | METHODS2[METHODS2["LINK"] = 31] = "LINK"; |
| 9862 | METHODS2[METHODS2["UNLINK"] = 32] = "UNLINK"; |
| 9863 | METHODS2[METHODS2["SOURCE"] = 33] = "SOURCE"; |
| 9864 | METHODS2[METHODS2["PRI"] = 34] = "PRI"; |
| 9865 | METHODS2[METHODS2["DESCRIBE"] = 35] = "DESCRIBE"; |
| 9866 | METHODS2[METHODS2["ANNOUNCE"] = 36] = "ANNOUNCE"; |
| 9867 | METHODS2[METHODS2["SETUP"] = 37] = "SETUP"; |
| 9868 | METHODS2[METHODS2["PLAY"] = 38] = "PLAY"; |
| 9869 | METHODS2[METHODS2["PAUSE"] = 39] = "PAUSE"; |
| 9870 | METHODS2[METHODS2["TEARDOWN"] = 40] = "TEARDOWN"; |
| 9871 | METHODS2[METHODS2["GET_PARAMETER"] = 41] = "GET_PARAMETER"; |
| 9872 | METHODS2[METHODS2["SET_PARAMETER"] = 42] = "SET_PARAMETER"; |
| 9873 | METHODS2[METHODS2["REDIRECT"] = 43] = "REDIRECT"; |
| 9874 | METHODS2[METHODS2["RECORD"] = 44] = "RECORD"; |
| 9875 | METHODS2[METHODS2["FLUSH"] = 45] = "FLUSH"; |
| 9876 | })(METHODS = exports2.METHODS || (exports2.METHODS = {})); |
| 9877 | exports2.METHODS_HTTP = [ |
| 9878 | METHODS.DELETE, |
| 9879 | METHODS.GET, |
| 9880 | METHODS.HEAD, |
| 9881 | METHODS.POST, |
| 9882 | METHODS.PUT, |
| 9883 | METHODS.CONNECT, |
| 9884 | METHODS.OPTIONS, |
| 9885 | METHODS.TRACE, |
| 9886 | METHODS.COPY, |
| 9887 | METHODS.LOCK, |
| 9888 | METHODS.MKCOL, |
| 9889 | METHODS.MOVE, |
| 9890 | METHODS.PROPFIND, |
| 9891 | METHODS.PROPPATCH, |
| 9892 | METHODS.SEARCH, |
| 9893 | METHODS.UNLOCK, |
| 9894 | METHODS.BIND, |
| 9895 | METHODS.REBIND, |
| 9896 | METHODS.UNBIND, |
| 9897 | METHODS.ACL, |
| 9898 | METHODS.REPORT, |
| 9899 | METHODS.MKACTIVITY, |
| 9900 | METHODS.CHECKOUT, |
| 9901 | METHODS.MERGE, |
| 9902 | METHODS["M-SEARCH"], |
| 9903 | METHODS.NOTIFY, |
| 9904 | METHODS.SUBSCRIBE, |
| 9905 | METHODS.UNSUBSCRIBE, |
| 9906 | METHODS.PATCH, |
| 9907 | METHODS.PURGE, |
| 9908 | METHODS.MKCALENDAR, |
| 9909 | METHODS.LINK, |
| 9910 | METHODS.UNLINK, |
| 9911 | METHODS.PRI, |
| 9912 | // TODO(indutny): should we allow it with HTTP? |
| 9913 | METHODS.SOURCE |
| 9914 | ]; |
| 9915 | exports2.METHODS_ICE = [ |
| 9916 | METHODS.SOURCE |
| 9917 | ]; |
| 9918 | exports2.METHODS_RTSP = [ |
| 9919 | METHODS.OPTIONS, |
| 9920 | METHODS.DESCRIBE, |
| 9921 | METHODS.ANNOUNCE, |
| 9922 | METHODS.SETUP, |
| 9923 | METHODS.PLAY, |
| 9924 | METHODS.PAUSE, |
| 9925 | METHODS.TEARDOWN, |
| 9926 | METHODS.GET_PARAMETER, |
| 9927 | METHODS.SET_PARAMETER, |
| 9928 | METHODS.REDIRECT, |
| 9929 | METHODS.RECORD, |
| 9930 | METHODS.FLUSH, |
| 9931 | // For AirPlay |
| 9932 | METHODS.GET, |
| 9933 | METHODS.POST |
| 9934 | ]; |
| 9935 | exports2.METHOD_MAP = utils_1.enumToMap(METHODS); |
| 9936 | exports2.H_METHOD_MAP = {}; |
| 9937 | Object.keys(exports2.METHOD_MAP).forEach((key) => { |
| 9938 | if (/^H/.test(key)) { |
| 9939 | exports2.H_METHOD_MAP[key] = exports2.METHOD_MAP[key]; |
| 9940 | } |
| 9941 | }); |
| 9942 | var FINISH; |
| 9943 | (function(FINISH2) { |
| 9944 | FINISH2[FINISH2["SAFE"] = 0] = "SAFE"; |
| 9945 | FINISH2[FINISH2["SAFE_WITH_CB"] = 1] = "SAFE_WITH_CB"; |
| 9946 | FINISH2[FINISH2["UNSAFE"] = 2] = "UNSAFE"; |
| 9947 | })(FINISH = exports2.FINISH || (exports2.FINISH = {})); |
| 9948 | exports2.ALPHA = []; |
| 9949 | for (let i = "A".charCodeAt(0); i <= "Z".charCodeAt(0); i++) { |
| 9950 | exports2.ALPHA.push(String.fromCharCode(i)); |
| 9951 | exports2.ALPHA.push(String.fromCharCode(i + 32)); |
| 9952 | } |
| 9953 | exports2.NUM_MAP = { |
| 9954 | 0: 0, |
| 9955 | 1: 1, |
| 9956 | 2: 2, |
| 9957 | 3: 3, |
| 9958 | 4: 4, |
| 9959 | 5: 5, |
| 9960 | 6: 6, |
| 9961 | 7: 7, |
| 9962 | 8: 8, |
| 9963 | 9: 9 |
| 9964 | }; |
| 9965 | exports2.HEX_MAP = { |
| 9966 | 0: 0, |
| 9967 | 1: 1, |
| 9968 | 2: 2, |
| 9969 | 3: 3, |
| 9970 | 4: 4, |
| 9971 | 5: 5, |
| 9972 | 6: 6, |
| 9973 | 7: 7, |
| 9974 | 8: 8, |
| 9975 | 9: 9, |
| 9976 | A: 10, |
| 9977 | B: 11, |
| 9978 | C: 12, |
| 9979 | D: 13, |
| 9980 | E: 14, |
| 9981 | F: 15, |
| 9982 | a: 10, |
| 9983 | b: 11, |
| 9984 | c: 12, |
| 9985 | d: 13, |
| 9986 | e: 14, |
| 9987 | f: 15 |
| 9988 | }; |
| 9989 | exports2.NUM = [ |
| 9990 | "0", |
| 9991 | "1", |
| 9992 | "2", |
| 9993 | "3", |
| 9994 | "4", |
| 9995 | "5", |
| 9996 | "6", |
| 9997 | "7", |
| 9998 | "8", |
| 9999 | "9" |
| 10000 | ]; |
| 10001 | exports2.ALPHANUM = exports2.ALPHA.concat(exports2.NUM); |
| 10002 | exports2.MARK = ["-", "_", ".", "!", "~", "*", "'", "(", ")"]; |
| 10003 | exports2.USERINFO_CHARS = exports2.ALPHANUM.concat(exports2.MARK).concat(["%", ";", ":", "&", "=", "+", "$", ","]); |
| 10004 | exports2.STRICT_URL_CHAR = [ |
| 10005 | "!", |
| 10006 | '"', |
| 10007 | "$", |
| 10008 | "%", |
| 10009 | "&", |
| 10010 | "'", |
| 10011 | "(", |
| 10012 | ")", |
| 10013 | "*", |
| 10014 | "+", |
| 10015 | ",", |
| 10016 | "-", |
| 10017 | ".", |
| 10018 | "/", |
| 10019 | ":", |
| 10020 | ";", |
| 10021 | "<", |
| 10022 | "=", |
| 10023 | ">", |
| 10024 | "@", |
| 10025 | "[", |
| 10026 | "\\", |
| 10027 | "]", |
| 10028 | "^", |
| 10029 | "_", |
| 10030 | "`", |
| 10031 | "{", |
| 10032 | "|", |
| 10033 | "}", |
| 10034 | "~" |
| 10035 | ].concat(exports2.ALPHANUM); |
| 10036 | exports2.URL_CHAR = exports2.STRICT_URL_CHAR.concat([" ", "\f"]); |
| 10037 | for (let i = 128; i <= 255; i++) { |
| 10038 | exports2.URL_CHAR.push(i); |
| 10039 | } |
| 10040 | exports2.HEX = exports2.NUM.concat(["a", "b", "c", "d", "e", "f", "A", "B", "C", "D", "E", "F"]); |
| 10041 | exports2.STRICT_TOKEN = [ |
| 10042 | "!", |
| 10043 | "#", |
| 10044 | "$", |
| 10045 | "%", |
| 10046 | "&", |
| 10047 | "'", |
| 10048 | "*", |
| 10049 | "+", |
| 10050 | "-", |
| 10051 | ".", |
| 10052 | "^", |
| 10053 | "_", |
| 10054 | "`", |
| 10055 | "|", |
| 10056 | "~" |
| 10057 | ].concat(exports2.ALPHANUM); |
| 10058 | exports2.TOKEN = exports2.STRICT_TOKEN.concat([" "]); |
| 10059 | exports2.HEADER_CHARS = [" "]; |
| 10060 | for (let i = 32; i <= 255; i++) { |
| 10061 | if (i !== 127) { |
| 10062 | exports2.HEADER_CHARS.push(i); |
| 10063 | } |
| 10064 | } |
| 10065 | exports2.CONNECTION_TOKEN_CHARS = exports2.HEADER_CHARS.filter((c) => c !== 44); |
| 10066 | exports2.MAJOR = exports2.NUM_MAP; |
| 10067 | exports2.MINOR = exports2.MAJOR; |
| 10068 | var HEADER_STATE; |
| 10069 | (function(HEADER_STATE2) { |
| 10070 | HEADER_STATE2[HEADER_STATE2["GENERAL"] = 0] = "GENERAL"; |
| 10071 | HEADER_STATE2[HEADER_STATE2["CONNECTION"] = 1] = "CONNECTION"; |
| 10072 | HEADER_STATE2[HEADER_STATE2["CONTENT_LENGTH"] = 2] = "CONTENT_LENGTH"; |
| 10073 | HEADER_STATE2[HEADER_STATE2["TRANSFER_ENCODING"] = 3] = "TRANSFER_ENCODING"; |
| 10074 | HEADER_STATE2[HEADER_STATE2["UPGRADE"] = 4] = "UPGRADE"; |
| 10075 | HEADER_STATE2[HEADER_STATE2["CONNECTION_KEEP_ALIVE"] = 5] = "CONNECTION_KEEP_ALIVE"; |
| 10076 | HEADER_STATE2[HEADER_STATE2["CONNECTION_CLOSE"] = 6] = "CONNECTION_CLOSE"; |
| 10077 | HEADER_STATE2[HEADER_STATE2["CONNECTION_UPGRADE"] = 7] = "CONNECTION_UPGRADE"; |
| 10078 | HEADER_STATE2[HEADER_STATE2["TRANSFER_ENCODING_CHUNKED"] = 8] = "TRANSFER_ENCODING_CHUNKED"; |
| 10079 | })(HEADER_STATE = exports2.HEADER_STATE || (exports2.HEADER_STATE = {})); |
| 10080 | exports2.SPECIAL_HEADERS = { |
| 10081 | "connection": HEADER_STATE.CONNECTION, |
| 10082 | "content-length": HEADER_STATE.CONTENT_LENGTH, |
| 10083 | "proxy-connection": HEADER_STATE.CONNECTION, |
| 10084 | "transfer-encoding": HEADER_STATE.TRANSFER_ENCODING, |
| 10085 | "upgrade": HEADER_STATE.UPGRADE |
| 10086 | }; |
| 10087 | } |
| 10088 | }); |
| 10089 | |
| 10090 | // node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/handler/RedirectHandler.js |
| 10091 | var require_RedirectHandler = __commonJS({ |
| 10092 | "node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/handler/RedirectHandler.js"(exports2, module2) { |
| 10093 | "use strict"; |
| 10094 | var util = require_util(); |
| 10095 | var { kBodyUsed } = require_symbols(); |
| 10096 | var assert = require("assert"); |
| 10097 | var { InvalidArgumentError: InvalidArgumentError2 } = require_errors(); |
| 10098 | var EE = require("events"); |
| 10099 | var redirectableStatusCodes = [300, 301, 302, 303, 307, 308]; |
| 10100 | var kBody = Symbol("body"); |
| 10101 | var BodyAsyncIterable = class { |
| 10102 | constructor(body) { |
| 10103 | this[kBody] = body; |
| 10104 | this[kBodyUsed] = false; |
| 10105 | } |
| 10106 | async *[Symbol.asyncIterator]() { |
| 10107 | assert(!this[kBodyUsed], "disturbed"); |
| 10108 | this[kBodyUsed] = true; |
| 10109 | yield* this[kBody]; |
| 10110 | } |
| 10111 | }; |
| 10112 | var RedirectHandler = class { |
| 10113 | constructor(dispatch, maxRedirections, opts, handler2) { |
| 10114 | if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) { |
| 10115 | throw new InvalidArgumentError2("maxRedirections must be a positive number"); |
| 10116 | } |
| 10117 | util.validateHandler(handler2, opts.method, opts.upgrade); |
| 10118 | this.dispatch = dispatch; |
| 10119 | this.location = null; |
| 10120 | this.abort = null; |
| 10121 | this.opts = { ...opts, maxRedirections: 0 }; |
| 10122 | this.maxRedirections = maxRedirections; |
| 10123 | this.handler = handler2; |
| 10124 | this.history = []; |
| 10125 | if (util.isStream(this.opts.body)) { |
| 10126 | if (util.bodyLength(this.opts.body) === 0) { |
| 10127 | this.opts.body.on("data", function() { |
| 10128 | assert(false); |
| 10129 | }); |
| 10130 | } |
| 10131 | if (typeof this.opts.body.readableDidRead !== "boolean") { |
| 10132 | this.opts.body[kBodyUsed] = false; |
| 10133 | EE.prototype.on.call(this.opts.body, "data", function() { |
| 10134 | this[kBodyUsed] = true; |
| 10135 | }); |
| 10136 | } |
| 10137 | } else if (this.opts.body && typeof this.opts.body.pipeTo === "function") { |
| 10138 | this.opts.body = new BodyAsyncIterable(this.opts.body); |
| 10139 | } else if (this.opts.body && typeof this.opts.body !== "string" && !ArrayBuffer.isView(this.opts.body) && util.isIterable(this.opts.body)) { |
| 10140 | this.opts.body = new BodyAsyncIterable(this.opts.body); |
| 10141 | } |
| 10142 | } |
| 10143 | onConnect(abort) { |
| 10144 | this.abort = abort; |
| 10145 | this.handler.onConnect(abort, { history: this.history }); |
| 10146 | } |
| 10147 | onUpgrade(statusCode, headers, socket) { |
| 10148 | this.handler.onUpgrade(statusCode, headers, socket); |
| 10149 | } |
| 10150 | onError(error) { |
| 10151 | this.handler.onError(error); |
| 10152 | } |
| 10153 | onHeaders(statusCode, headers, resume, statusText) { |
| 10154 | this.location = this.history.length >= this.maxRedirections || util.isDisturbed(this.opts.body) ? null : parseLocation(statusCode, headers); |
| 10155 | if (this.opts.origin) { |
| 10156 | this.history.push(new URL(this.opts.path, this.opts.origin)); |
| 10157 | } |
| 10158 | if (!this.location) { |
| 10159 | return this.handler.onHeaders(statusCode, headers, resume, statusText); |
| 10160 | } |
| 10161 | const { origin, pathname, search } = util.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin))); |
| 10162 | const path5 = search ? `${pathname}${search}` : pathname; |
| 10163 | this.opts.headers = cleanRequestHeaders(this.opts.headers, statusCode === 303, this.opts.origin !== origin); |
| 10164 | this.opts.path = path5; |
| 10165 | this.opts.origin = origin; |
| 10166 | this.opts.maxRedirections = 0; |
| 10167 | this.opts.query = null; |
| 10168 | if (statusCode === 303 && this.opts.method !== "HEAD") { |
| 10169 | this.opts.method = "GET"; |
| 10170 | this.opts.body = null; |
| 10171 | } |
| 10172 | } |
| 10173 | onData(chunk) { |
| 10174 | if (this.location) { |
| 10175 | } else { |
| 10176 | return this.handler.onData(chunk); |
| 10177 | } |
| 10178 | } |
| 10179 | onComplete(trailers) { |
| 10180 | if (this.location) { |
| 10181 | this.location = null; |
| 10182 | this.abort = null; |
| 10183 | this.dispatch(this.opts, this); |
| 10184 | } else { |
| 10185 | this.handler.onComplete(trailers); |
| 10186 | } |
| 10187 | } |
| 10188 | onBodySent(chunk) { |
| 10189 | if (this.handler.onBodySent) { |
| 10190 | this.handler.onBodySent(chunk); |
| 10191 | } |
| 10192 | } |
| 10193 | }; |
| 10194 | function parseLocation(statusCode, headers) { |
| 10195 | if (redirectableStatusCodes.indexOf(statusCode) === -1) { |
| 10196 | return null; |
| 10197 | } |
| 10198 | for (let i = 0; i < headers.length; i += 2) { |
| 10199 | if (headers[i].toString().toLowerCase() === "location") { |
| 10200 | return headers[i + 1]; |
| 10201 | } |
| 10202 | } |
| 10203 | } |
| 10204 | function shouldRemoveHeader(header, removeContent, unknownOrigin) { |
| 10205 | if (header.length === 4) { |
| 10206 | return util.headerNameToString(header) === "host"; |
| 10207 | } |
| 10208 | if (removeContent && util.headerNameToString(header).startsWith("content-")) { |
| 10209 | return true; |
| 10210 | } |
| 10211 | if (unknownOrigin && (header.length === 13 || header.length === 6 || header.length === 19)) { |
| 10212 | const name = util.headerNameToString(header); |
| 10213 | return name === "authorization" || name === "cookie" || name === "proxy-authorization"; |
| 10214 | } |
| 10215 | return false; |
| 10216 | } |
| 10217 | function cleanRequestHeaders(headers, removeContent, unknownOrigin) { |
| 10218 | const ret = []; |
| 10219 | if (Array.isArray(headers)) { |
| 10220 | for (let i = 0; i < headers.length; i += 2) { |
| 10221 | if (!shouldRemoveHeader(headers[i], removeContent, unknownOrigin)) { |
| 10222 | ret.push(headers[i], headers[i + 1]); |
| 10223 | } |
| 10224 | } |
| 10225 | } else if (headers && typeof headers === "object") { |
| 10226 | for (const key of Object.keys(headers)) { |
| 10227 | if (!shouldRemoveHeader(key, removeContent, unknownOrigin)) { |
| 10228 | ret.push(key, headers[key]); |
| 10229 | } |
| 10230 | } |
| 10231 | } else { |
| 10232 | assert(headers == null, "headers must be an object or an array"); |
| 10233 | } |
| 10234 | return ret; |
| 10235 | } |
| 10236 | module2.exports = RedirectHandler; |
| 10237 | } |
| 10238 | }); |
| 10239 | |
| 10240 | // node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/interceptor/redirectInterceptor.js |
| 10241 | var require_redirectInterceptor = __commonJS({ |
| 10242 | "node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/interceptor/redirectInterceptor.js"(exports2, module2) { |
| 10243 | "use strict"; |
| 10244 | var RedirectHandler = require_RedirectHandler(); |
| 10245 | function createRedirectInterceptor({ maxRedirections: defaultMaxRedirections }) { |
| 10246 | return (dispatch) => { |
| 10247 | return function Intercept(opts, handler2) { |
| 10248 | const { maxRedirections = defaultMaxRedirections } = opts; |
| 10249 | if (!maxRedirections) { |
| 10250 | return dispatch(opts, handler2); |
| 10251 | } |
| 10252 | const redirectHandler = new RedirectHandler(dispatch, maxRedirections, opts, handler2); |
| 10253 | opts = { ...opts, maxRedirections: 0 }; |
| 10254 | return dispatch(opts, redirectHandler); |
| 10255 | }; |
| 10256 | }; |
| 10257 | } |
| 10258 | module2.exports = createRedirectInterceptor; |
| 10259 | } |
| 10260 | }); |
| 10261 | |
| 10262 | // node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/llhttp/llhttp-wasm.js |
| 10263 | var require_llhttp_wasm = __commonJS({ |
| 10264 | "node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/llhttp/llhttp-wasm.js"(exports2, module2) { |
| 10265 | module2.exports = "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"; |
| 10266 | } |
| 10267 | }); |
| 10268 | |
| 10269 | // node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/llhttp/llhttp_simd-wasm.js |
| 10270 | var require_llhttp_simd_wasm = __commonJS({ |
| 10271 | "node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/llhttp/llhttp_simd-wasm.js"(exports2, module2) { |
| 10272 | module2.exports = "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"; |
| 10273 | } |
| 10274 | }); |
| 10275 | |
| 10276 | // node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/client.js |
| 10277 | var require_client = __commonJS({ |
| 10278 | "node_modules/.pnpm/undici@5.29.0/node_modules/undici/lib/client.js"(exports2, module2) { |
| 10279 | "use strict"; |
| 10280 | var assert = require("assert"); |
| 10281 | var net = require("net"); |
| 10282 | var http = require("http"); |
| 10283 | var { pipeline } = require("stream"); |
| 10284 | var util = require_util(); |
| 10285 | var timers = require_timers(); |
| 10286 | var Request = require_request(); |
| 10287 | var DispatcherBase = require_dispatcher_base(); |
| 10288 | var { |
| 10289 | RequestContentLengthMismatchError, |
| 10290 | ResponseContentLengthMismatchError, |
| 10291 | InvalidArgumentError: InvalidArgumentError2, |
| 10292 | RequestAbortedError, |
| 10293 | HeadersTimeoutError, |
| 10294 | HeadersOverflowError, |
| 10295 | SocketError, |
| 10296 | InformationalError, |
| 10297 | BodyTimeoutError, |
| 10298 | HTTPParserError, |
| 10299 | ResponseExceededMaxSizeError, |
| 10300 | ClientDestroyedError |
| 10301 | } = require_errors(); |
| 10302 | var buildConnector = require_connect(); |
| 10303 | var { |
| 10304 | kUrl, |
| 10305 | kReset, |
| 10306 | kServerName, |
| 10307 | kClient, |
| 10308 | kBusy, |
| 10309 | kParser, |
| 10310 | kConnect, |
| 10311 | kBlocking, |
| 10312 | kResuming, |
| 10313 | kRunning, |
| 10314 | kPending, |
| 10315 | kSize, |
| 10316 | kWriting, |
| 10317 | kQueue, |
| 10318 | kConnected, |
| 10319 | kConnecting, |
| 10320 | kNeedDrain, |
| 10321 | kNoRef, |
| 10322 | kKeepAliveDefaultTimeout, |
| 10323 | kHostHeader, |
| 10324 | kPendingIdx, |
| 10325 | kRunningIdx, |
| 10326 | kError, |
| 10327 | kPipelining, |
| 10328 | kSocket, |
| 10329 | kKeepAliveTimeoutValue, |
| 10330 | kMaxHeadersSize, |
| 10331 | kKeepAliveMaxTimeout, |
| 10332 | kKeepAliveTimeoutThreshold, |
| 10333 | kHeadersTimeout, |
| 10334 | kBodyTimeout, |
| 10335 | kStrictContentLength, |
| 10336 | kConnector, |
| 10337 | kMaxRedirections, |
| 10338 | kMaxRequests, |
| 10339 | kCounter, |
| 10340 | kClose, |
| 10341 | kDestroy, |
| 10342 | kDispatch, |
| 10343 | kInterceptors, |
| 10344 | kLocalAddress, |
| 10345 | kMaxResponseSize, |
| 10346 | kHTTPConnVersion, |
| 10347 | // HTTP2 |
| 10348 | kHost, |
| 10349 | kHTTP2Session, |
| 10350 | kHTTP2SessionState, |
| 10351 | kHTTP2BuildRequest, |
| 10352 | kHTTP2CopyHeaders, |
| 10353 | kHTTP1BuildRequest |
| 10354 | } = require_symbols(); |
| 10355 | var http2; |
| 10356 | try { |
| 10357 | http2 = require("http2"); |
| 10358 | } catch { |
| 10359 | http2 = { constants: {} }; |
| 10360 | } |
| 10361 | var { |
| 10362 | constants: { |
| 10363 | HTTP2_HEADER_AUTHORITY, |
| 10364 | HTTP2_HEADER_METHOD, |
| 10365 | HTTP2_HEADER_PATH, |
| 10366 | HTTP2_HEADER_SCHEME, |
| 10367 | HTTP2_HEADER_CONTENT_LENGTH, |
| 10368 | HTTP2_HEADER_EXPECT, |
| 10369 | HTTP2_HEADER_STATUS |
| 10370 | } |
| 10371 | } = http2; |
| 10372 | var h2ExperimentalWarned = false; |
| 10373 | var FastBuffer = Buffer[Symbol.species]; |
| 10374 | var kClosedResolve = Symbol("kClosedResolve"); |
| 10375 | var channels = {}; |
| 10376 | try { |
| 10377 | const diagnosticsChannel = require("diagnostics_channel"); |
| 10378 | channels.sendHeaders = diagnosticsChannel.channel("undici:client:sendHeaders"); |
| 10379 | channels.beforeConnect = diagnosticsChannel.channel("undici:client:beforeConnect"); |
| 10380 | channels.connectError = diagnosticsChannel.channel("undici:client:connectError"); |
| 10381 | channels.connected = diagnosticsChannel.channel("undici:client:connected"); |
| 10382 | } catch { |
| 10383 | channels.sendHeaders = { hasSubscribers: false }; |
| 10384 | channels.beforeConnect = { hasSubscribers: false }; |
| 10385 | channels.connectError = { hasSubscribers: false }; |
| 10386 | channels.connected = { hasSubscribers: false }; |
| 10387 | } |
| 10388 | var Client = class extends DispatcherBase { |
| 10389 | /** |
| 10390 | * |
| 10391 | * @param {string|URL} url |
| 10392 | * @param {import('../types/client').Client.Options} options |
| 10393 | */ |
| 10394 | constructor(url, { |
| 10395 | interceptors, |
| 10396 | maxHeaderSize, |
| 10397 | headersTimeout, |
| 10398 | socketTimeout, |
| 10399 | requestTimeout, |
| 10400 | connectTimeout, |
| 10401 | bodyTimeout, |
| 10402 | idleTimeout, |
| 10403 | keepAlive, |
| 10404 | keepAliveTimeout, |
| 10405 | maxKeepAliveTimeout, |
| 10406 | keepAliveMaxTimeout, |
| 10407 | keepAliveTimeoutThreshold, |
| 10408 | socketPath, |
| 10409 | pipelining, |
| 10410 | tls, |
| 10411 | strictContentLength, |
| 10412 | maxCachedSessions, |
| 10413 | maxRedirections, |
| 10414 | connect: connect2, |
| 10415 | maxRequestsPerClient, |
| 10416 | localAddress, |
| 10417 | maxResponseSize, |
| 10418 | autoSelectFamily, |
| 10419 | autoSelectFamilyAttemptTimeout, |
| 10420 | // h2 |
| 10421 | allowH2, |
| 10422 | maxConcurrentStreams |
| 10423 | } = {}) { |
| 10424 | super(); |
| 10425 | if (keepAlive !== void 0) { |
| 10426 | throw new InvalidArgumentError2("unsupported keepAlive, use pipelining=0 instead"); |
| 10427 | } |
| 10428 | if (socketTimeout !== void 0) { |
| 10429 | throw new InvalidArgumentError2("unsupported socketTimeout, use headersTimeout & bodyTimeout instead"); |
| 10430 | } |
| 10431 | if (requestTimeout !== void 0) { |
| 10432 | throw new InvalidArgumentError2("unsupported requestTimeout, use headersTimeout & bodyTimeout instead"); |
| 10433 | } |
| 10434 | if (idleTimeout !== void 0) { |
| 10435 | throw new InvalidArgumentError2("unsupported idleTimeout, use keepAliveTimeout instead"); |
| 10436 | } |
| 10437 | if (maxKeepAliveTimeout !== void 0) { |
| 10438 | throw new InvalidArgumentError2("unsupported maxKeepAliveTimeout, use keepAliveMaxTimeout instead"); |
| 10439 | } |
| 10440 | if (maxHeaderSize != null && !Number.isFinite(maxHeaderSize)) { |
| 10441 | throw new InvalidArgumentError2("invalid maxHeaderSize"); |
| 10442 | } |
| 10443 | if (socketPath != null && typeof socketPath !== "string") { |
| 10444 | throw new InvalidArgumentError2("invalid socketPath"); |
| 10445 | } |
| 10446 | if (connectTimeout != null && (!Number.isFinite(connectTimeout) || connectTimeout < 0)) { |
| 10447 | throw new InvalidArgumentError2("invalid connectTimeout"); |
| 10448 | } |
| 10449 | if (keepAliveTimeout != null && (!Number.isFinite(keepAliveTimeout) || keepAliveTimeout <= 0)) { |
| 10450 | throw new InvalidArgumentError2("invalid keepAliveTimeout"); |
| 10451 | } |
| 10452 | if (keepAliveMaxTimeout != null && (!Number.isFinite(keepAliveMaxTimeout) || keepAliveMaxTimeout <= 0)) { |
| 10453 | throw new InvalidArgumentError2("invalid keepAliveMaxTimeout"); |
| 10454 | } |
| 10455 | if (keepAliveTimeoutThreshold != null && !Number.isFinite(keepAliveTimeoutThreshold)) { |
| 10456 | throw new InvalidArgumentError2("invalid keepAliveTimeoutThreshold"); |
| 10457 | } |
| 10458 | if (headersTimeout != null && (!Number.isInteger(headersTimeout) || headersTimeout < 0)) { |
| 10459 | throw new InvalidArgumentError2("headersTimeout must be a positive integer or zero"); |
| 10460 | } |
| 10461 | if (bodyTimeout != null && (!Number.isInteger(bodyTimeout) || bodyTimeout < 0)) { |
| 10462 | throw new InvalidArgumentError2("bodyTimeout must be a positive integer or zero"); |
| 10463 | } |
| 10464 | if (connect2 != null && typeof connect2 !== "function" && typeof connect2 !== "object") { |
| 10465 | throw new InvalidArgumentError2("connect must be a function or an object"); |
| 10466 | } |
| 10467 | if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) { |
| 10468 | throw new InvalidArgumentError2("maxRedirections must be a positive number"); |
| 10469 | } |
| 10470 | if (maxRequestsPerClient != null && (!Number.isInteger(maxRequestsPerClient) || maxRequestsPerClient < 0)) { |
| 10471 | throw new InvalidArgumentError2("maxRequestsPerClient must be a positive number"); |
| 10472 | } |
| 10473 | if (localAddress != null && (typeof localAddress !== "string" || net.isIP(localAddress) === 0)) { |
| 10474 | throw new InvalidArgumentError2("localAddress must be valid string IP address"); |
| 10475 | } |
| 10476 | if (maxResponseSize != null && (!Number.isInteger(maxResponseSize) || maxResponseSize < -1)) { |
| 10477 | throw new InvalidArgumentError2("maxResponseSize must be a positive number"); |
| 10478 | } |
| 10479 | if (autoSelectFamilyAttemptTimeout != null && (!Number.isInteger(autoSelectFamilyAttemptTimeout) || autoSelectFamilyAttemptTimeout < -1)) { |
| 10480 | throw new InvalidArgumentError2("autoSelectFamilyAttemptTimeout must be a positive number"); |
| 10481 | } |
| 10482 | if (allowH2 != null && typeof allowH2 !== "boolean") { |
| 10483 | throw new InvalidArgumentError2("allowH2 must be a valid boolean value"); |
| 10484 | } |
| 10485 | if (maxConcurrentStreams != null && (typeof maxConcurrentStreams !== "number" || maxConcurrentStreams < 1)) { |
| 10486 | throw new InvalidArgumentError2("maxConcurrentStreams must be a possitive integer, greater than 0"); |
| 10487 | } |
| 10488 | if (typeof connect2 !== "function") { |
| 10489 | connect2 = buildConnector({ |
| 10490 | ...tls, |
| 10491 | maxCachedSessions, |
| 10492 | allowH2, |
| 10493 | socketPath, |
| 10494 | timeout: connectTimeout, |
| 10495 | ...util.nodeHasAutoSelectFamily && autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0, |
| 10496 | ...connect2 |
| 10497 | }); |
| 10498 | } |
| 10499 | this[kInterceptors] = interceptors && interceptors.Client && Array.isArray(interceptors.Client) ? interceptors.Client : [createRedirectInterceptor({ maxRedirections })]; |
| 10500 | this[kUrl] = util.parseOrigin(url); |
| 10501 | this[kConnector] = connect2; |
| 10502 | this[kSocket] = null; |
| 10503 | this[kPipelining] = pipelining != null ? pipelining : 1; |
| 10504 | this[kMaxHeadersSize] = maxHeaderSize || http.maxHeaderSize; |
| 10505 | this[kKeepAliveDefaultTimeout] = keepAliveTimeout == null ? 4e3 : keepAliveTimeout; |
| 10506 | this[kKeepAliveMaxTimeout] = keepAliveMaxTimeout == null ? 6e5 : keepAliveMaxTimeout; |
| 10507 | this[kKeepAliveTimeoutThreshold] = keepAliveTimeoutThreshold == null ? 1e3 : keepAliveTimeoutThreshold; |
| 10508 | this[kKeepAliveTimeoutValue] = this[kKeepAliveDefaultTimeout]; |
| 10509 | this[kServerName] = null; |
| 10510 | this[kLocalAddress] = localAddress != null ? localAddress : null; |
| 10511 | this[kResuming] = 0; |
| 10512 | this[kNeedDrain] = 0; |
| 10513 | this[kHostHeader] = `host: ${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ""}\r |
| 10514 | `; |
| 10515 | this[kBodyTimeout] = bodyTimeout != null ? bodyTimeout : 3e5; |
| 10516 | this[kHeadersTimeout] = headersTimeout != null ? headersTimeout : 3e5; |
| 10517 | this[kStrictContentLength] = strictContentLength == null ? true : strictContentLength; |
| 10518 | this[kMaxRedirections] = maxRedirections; |
| 10519 | this[kMaxRequests] = maxRequestsPerClient; |
| 10520 | this[kClosedResolve] = null; |
| 10521 | this[kMaxResponseSize] = maxResponseSize > -1 ? maxResponseSize : -1; |
| 10522 | this[kHTTPConnVersion] = "h1"; |
| 10523 | this[kHTTP2Session] = null; |
| 10524 | this[kHTTP2SessionState] = !allowH2 ? null : { |
| 10525 | // streams: null, // Fixed queue of streams - For future support of `push` |
| 10526 | openStreams: 0, |
| 10527 | // Keep track of them to decide wether or not unref the session |
| 10528 | maxConcurrentStreams: maxConcurrentStreams != null ? maxConcurrentStreams : 100 |
| 10529 | // Max peerConcurrentStreams for a Node h2 server |
| 10530 | }; |
| 10531 | this[kHost] = `${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ""}`; |
| 10532 | this[kQueue] = []; |
| 10533 | this[kRunningIdx] = 0; |
| 10534 | this[kPendingIdx] = 0; |
| 10535 | } |
| 10536 | get pipelining() { |
| 10537 | return this[kPipelining]; |
| 10538 | } |
| 10539 | set pipelining(value) { |
| 10540 | this[kPipelining] = value; |
| 10541 | resume(this, true); |
| 10542 | } |
| 10543 | get [kPending]() { |
| 10544 | return this[kQueue].length - this[kPendingIdx]; |
| 10545 | } |
| 10546 | get [kRunning]() { |
| 10547 | return this[kPendingIdx] - this[kRunningIdx]; |
| 10548 | } |
| 10549 | get [kSize]() { |
| 10550 | return this[kQueue].length - this[kRunningIdx]; |
| 10551 | } |
| 10552 | get [kConnected]() { |
| 10553 | return !!this[kSocket] && !this[kConnecting] && !this[kSocket].destroyed; |
| 10554 | } |
| 10555 | get [kBusy]() { |
| 10556 | const socket = this[kSocket]; |
| 10557 | return socket && (socket[kReset] || socket[kWriting] || socket[kBlocking]) || this[kSize] >= (this[kPipelining] || 1) || this[kPending] > 0; |
| 10558 | } |
| 10559 | /* istanbul ignore: only used for test */ |
| 10560 | [kConnect](cb) { |
| 10561 | connect(this); |
| 10562 | this.once("connect", cb); |
| 10563 | } |
| 10564 | [kDispatch](opts, handler2) { |
| 10565 | const origin = opts.origin || this[kUrl].origin; |
| 10566 | const request2 = this[kHTTPConnVersion] === "h2" ? Request[kHTTP2BuildRequest](origin, opts, handler2) : Request[kHTTP1BuildRequest](origin, opts, handler2); |
| 10567 | this[kQueue].push(request2); |
| 10568 | if (this[kResuming]) { |
| 10569 | } else if (util.bodyLength(request2.body) == null && util.isIterable(request2.body)) { |
| 10570 | this[kResuming] = 1; |
| 10571 | process.nextTick(resume, this); |
| 10572 | } else { |
| 10573 | resume(this, true); |
| 10574 | } |
| 10575 | if (this[kResuming] && this[kNeedDrain] !== 2 && this[kBusy]) { |
| 10576 | this[kNeedDrain] = 2; |
| 10577 | } |
| 10578 | return this[kNeedDrain] < 2; |
| 10579 | } |
| 10580 | async [kClose]() { |
| 10581 | return new Promise((resolve) => { |
| 10582 | if (!this[kSize]) { |
| 10583 | resolve(null); |
| 10584 | } else { |
| 10585 | this[kClosedResolve] = resolve; |
| 10586 | } |
| 10587 | }); |
| 10588 | } |
| 10589 | async [kDestroy](err) { |
| 10590 | return new Promise((resolve) => { |
| 10591 | const requests = this[kQueue].splice(this[kPendingIdx]); |
| 10592 | for (let i = 0; i < requests.length; i++) { |
| 10593 | const request2 = requests[i]; |
| 10594 | errorRequest(this, request2, err); |
| 10595 | } |
| 10596 | const callback = () => { |
| 10597 | if (this[kClosedResolve]) { |
| 10598 | this[kClosedResolve](); |
| 10599 | this[kClosedResolve] = null; |
| 10600 | } |
| 10601 | resolve(); |
| 10602 | }; |
| 10603 | if (this[kHTTP2Session] != null) { |
| 10604 | util.destroy(this[kHTTP2Session], err); |
| 10605 | this[kHTTP2Session] = null; |
| 10606 | this[kHTTP2SessionState] = null; |
| 10607 | } |
| 10608 | if (!this[kSocket]) { |
| 10609 | queueMicrotask(callback); |
| 10610 | } else { |
| 10611 | util.destroy(this[kSocket].on("close", callback), err); |
| 10612 | } |
| 10613 | resume(this); |
| 10614 | }); |
| 10615 | } |
| 10616 | }; |
| 10617 | function onHttp2SessionError(err) { |
| 10618 | assert(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID"); |
| 10619 | this[kSocket][kError] = err; |
| 10620 | onError(this[kClient], err); |
| 10621 | } |
| 10622 | function onHttp2FrameError(type, code, id) { |
| 10623 | const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`); |
| 10624 | if (id === 0) { |
| 10625 | this[kSocket][kError] = err; |
| 10626 | onError(this[kClient], err); |
| 10627 | } |
| 10628 | } |
| 10629 | function onHttp2SessionEnd() { |
| 10630 | util.destroy(this, new SocketError("other side closed")); |
| 10631 | util.destroy(this[kSocket], new SocketError("other side closed")); |
| 10632 | } |
| 10633 | function onHTTP2GoAway(code) { |
| 10634 | const client = this[kClient]; |
| 10635 | const err = new InformationalError(`HTTP/2: "GOAWAY" frame received with code ${code}`); |
| 10636 | client[kSocket] = null; |
| 10637 | client[kHTTP2Session] = null; |
| 10638 | if (client.destroyed) { |
| 10639 | assert(this[kPending] === 0); |
| 10640 | const requests = client[kQueue].splice(client[kRunningIdx]); |
| 10641 | for (let i = 0; i < requests.length; i++) { |
| 10642 | const request2 = requests[i]; |
| 10643 | errorRequest(this, request2, err); |
| 10644 | } |
| 10645 | } else if (client[kRunning] > 0) { |
| 10646 | const request2 = client[kQueue][client[kRunningIdx]]; |
| 10647 | client[kQueue][client[kRunningIdx]++] = null; |
| 10648 | errorRequest(client, request2, err); |
| 10649 | } |
| 10650 | client[kPendingIdx] = client[kRunningIdx]; |
| 10651 | assert(client[kRunning] === 0); |
| 10652 | client.emit( |
| 10653 | "disconnect", |
| 10654 | client[kUrl], |
| 10655 | [client], |
| 10656 | err |
| 10657 | ); |
| 10658 | resume(client); |
| 10659 | } |
| 10660 | var constants = require_constants3(); |
| 10661 | var createRedirectInterceptor = require_redirectInterceptor(); |
| 10662 | var EMPTY_BUF = Buffer.alloc(0); |
| 10663 | async function lazyllhttp() { |
| 10664 | const llhttpWasmData = process.env.JEST_WORKER_ID ? require_llhttp_wasm() : void 0; |
| 10665 | let mod; |
| 10666 | try { |
| 10667 | mod = await WebAssembly.compile(Buffer.from(require_llhttp_simd_wasm(), "base64")); |
| 10668 | } catch (e) { |
| 10669 | mod = await WebAssembly.compile(Buffer.from(llhttpWasmData || require_llhttp_wasm(), "base64")); |
| 10670 | } |
| 10671 | return await WebAssembly.instantiate(mod, { |
| 10672 | env: { |
| 10673 | /* eslint-disable camelcase */ |
| 10674 | wasm_on_url: (p, at, len) => { |
| 10675 | return 0; |
| 10676 | }, |
| 10677 | wasm_on_status: (p, at, len) => { |
| 10678 | assert.strictEqual(currentParser.ptr, p); |
| 10679 | const start = at - currentBufferPtr + currentBufferRef.byteOffset; |
| 10680 | return currentParser.onStatus(new FastBuffer(currentBufferRef.buffer, start, len)) || 0; |
| 10681 | }, |
| 10682 | wasm_on_message_begin: (p) => { |
| 10683 | assert.strictEqual(currentParser.ptr, p); |
| 10684 | return currentParser.onMessageBegin() || 0; |
| 10685 | }, |
| 10686 | wasm_on_header_field: (p, at, len) => { |
| 10687 | assert.strictEqual(currentParser.ptr, p); |
| 10688 | const start = at - currentBufferPtr + currentBufferRef.byteOffset; |
| 10689 | return currentParser.onHeaderField(new FastBuffer(currentBufferRef.buffer, start, len)) || 0; |
| 10690 | }, |
| 10691 | wasm_on_header_value: (p, at, len) => { |
| 10692 | assert.strictEqual(currentParser.ptr, p); |
| 10693 | const start = at - currentBufferPtr + currentBufferRef.byteOffset; |
| 10694 | return currentParser.onHeaderValue(new FastBuffer(currentBufferRef.buffer, start, len)) || 0; |
| 10695 | }, |
| 10696 | wasm_on_headers_complete: (p, statusCode, upgrade, shouldKeepAlive) => { |
| 10697 | assert.strictEqual(currentParser.ptr, p); |
| 10698 | return currentParser.onHeadersComplete(statusCode, Boolean(upgrade), Boolean(shouldKeepAlive)) || 0; |
| 10699 | }, |
| 10700 | wasm_on_body: (p, at, len) => { |
| 10701 | assert.strictEqual(currentParser.ptr, p); |
| 10702 | const start = at - currentBufferPtr + currentBufferRef.byteOffset; |
| 10703 | return currentParser.onBody(new FastBuffer(currentBufferRef.buffer, start, len)) || 0; |
| 10704 | }, |
| 10705 | wasm_on_message_complete: (p) => { |
| 10706 | assert.strictEqual(currentParser.ptr, p); |
| 10707 | return currentParser.onMessageComplete() || 0; |
| 10708 | } |
| 10709 | /* eslint-enable camelcase */ |
| 10710 | } |
| 10711 | }); |
| 10712 | } |
| 10713 | var llhttpInstance = null; |
| 10714 | var llhttpPromise = lazyllhttp(); |
| 10715 | llhttpPromise.catch(); |
| 10716 | var currentParser = null; |
| 10717 | var currentBufferRef = null; |
| 10718 | var currentBufferSize = 0; |
| 10719 | var currentBufferPtr = null; |
| 10720 | var TIMEOUT_HEADERS = 1; |
| 10721 | var TIMEOUT_BODY = 2; |
| 10722 | var TIMEOUT_IDLE = 3; |
| 10723 | var Parser = class { |
| 10724 | constructor(client, socket, { exports: exports3 }) { |
| 10725 | assert(Number.isFinite(client[kMaxHeadersSize]) && client[kMaxHeadersSize] > 0); |
| 10726 | this.llhttp = exports3; |
| 10727 | this.ptr = this.llhttp.llhttp_alloc(constants.TYPE.RESPONSE); |
| 10728 | this.client = client; |
| 10729 | this.socket = socket; |
| 10730 | this.timeout = null; |
| 10731 | this.timeoutValue = null; |
| 10732 | this.timeoutType = null; |
| 10733 | this.statusCode = null; |
| 10734 | this.statusText = ""; |
| 10735 | this.upgrade = false; |
| 10736 | this.headers = []; |
| 10737 | this.headersSize = 0; |
| 10738 | this.headersMaxSize = client[kMaxHeadersSize]; |
| 10739 | this.shouldKeepAlive = false; |
| 10740 | this.paused = false; |
| 10741 | this.resume = this.resume.bind(this); |
| 10742 | this.bytesRead = 0; |
| 10743 | this.keepAlive = ""; |
| 10744 | this.contentLength = ""; |
| 10745 | this.connection = ""; |
| 10746 | this.maxResponseSize = client[kMaxResponseSize]; |
| 10747 | } |
| 10748 | setTimeout(value, type) { |
| 10749 | this.timeoutType = type; |
| 10750 | if (value !== this.timeoutValue) { |
| 10751 | timers.clearTimeout(this.timeout); |
| 10752 | if (value) { |
| 10753 | this.timeout = timers.setTimeout(onParserTimeout, value, this); |
| 10754 | if (this.timeout.unref) { |
| 10755 | this.timeout.unref(); |
| 10756 | } |
| 10757 | } else { |
| 10758 | this.timeout = null; |
| 10759 | } |
| 10760 | this.timeoutValue = value; |
| 10761 | } else if (this.timeout) { |
| 10762 | if (this.timeout.refresh) { |
| 10763 | this.timeout.refresh(); |
| 10764 | } |
| 10765 | } |
| 10766 | } |
| 10767 | resume() { |
| 10768 | if (this.socket.destroyed || !this.paused) { |
| 10769 | return; |
| 10770 | } |
| 10771 | assert(this.ptr != null); |
| 10772 | assert(currentParser == null); |
| 10773 | this.llhttp.llhttp_resume(this.ptr); |
| 10774 | assert(this.timeoutType === TIMEOUT_BODY); |
| 10775 | if (this.timeout) { |
| 10776 | if (this.timeout.refresh) { |
| 10777 | this.timeout.refresh(); |
| 10778 | } |
| 10779 | } |
| 10780 | this.paused = false; |
| 10781 | this.execute(this.socket.read() || EMPTY_BUF); |
| 10782 | this.readMore(); |
| 10783 | } |
| 10784 | readMore() { |
| 10785 | while (!this.paused && this.ptr) { |
| 10786 | const chunk = this.socket.read(); |
| 10787 | if (chunk === null) { |
| 10788 | break; |
| 10789 | } |
| 10790 | this.execute(chunk); |
| 10791 | } |
| 10792 | } |
| 10793 | execute(data) { |
| 10794 | assert(this.ptr != null); |
| 10795 | assert(currentParser == null); |
| 10796 | assert(!this.paused); |
| 10797 | const { socket, llhttp } = this; |
| 10798 | if (data.length > currentBufferSize) { |
| 10799 | if (currentBufferPtr) { |
| 10800 | llhttp.free(currentBufferPtr); |
| 10801 | } |
| 10802 | currentBufferSize = Math.ceil(data.length / 4096) * 4096; |
| 10803 | currentBufferPtr = llhttp.malloc(currentBufferSize); |
| 10804 | } |
| 10805 | new Uint8Array(llhttp.memory.buffer, currentBufferPtr, currentBufferSize).set(data); |
| 10806 | try { |
| 10807 | let ret; |
| 10808 | try { |
| 10809 | currentBufferRef = data; |
| 10810 | currentParser = this; |
| 10811 | ret = llhttp.llhttp_execute(this.ptr, currentBufferPtr, data.length); |
| 10812 | } catch (err) { |
| 10813 | throw err; |
| 10814 | } finally { |
| 10815 | currentParser = null; |
| 10816 | currentBufferRef = null; |
| 10817 | } |
| 10818 | const offset = llhttp.llhttp_get_error_pos(this.ptr) - currentBufferPtr; |
| 10819 | if (ret === constants.ERROR.PAUSED_UPGRADE) { |
| 10820 | this.onUpgrade(data.slice(offset)); |
| 10821 | } else if (ret === constants.ERROR.PAUSED) { |
| 10822 | this.paused = true; |
| 10823 | socket.unshift(data.slice(offset)); |
| 10824 | } else if (ret !== constants.ERROR.OK) { |
| 10825 | const ptr = llhttp.llhttp_get_error_reason(this.ptr); |
| 10826 | let message = ""; |
| 10827 | if (ptr) { |
| 10828 | const len = new Uint8Array(llhttp.memory.buffer, ptr).indexOf(0); |
| 10829 | message = "Response does not match the HTTP/1.1 protocol (" + Buffer.from(llhttp.memory.buffer, ptr, len).toString() + ")"; |
| 10830 | } |
| 10831 | throw new HTTPParserError(message, constants.ERROR[ret], data.slice(offset)); |
| 10832 | } |
| 10833 | } catch (err) { |
| 10834 | util.destroy(socket, err); |
| 10835 | } |
| 10836 | } |
| 10837 | destroy() { |
| 10838 | assert(this.ptr != null); |
| 10839 | assert(currentParser == null); |
| 10840 | this.llhttp.llhttp_free(this.ptr); |
| 10841 | this.ptr = null; |
| 10842 | timers.clearTimeout(this.timeout); |
| 10843 | this.timeout = null; |
| 10844 | this.timeoutValue = null; |
| 10845 | this.timeoutType = null; |
| 10846 | this.paused = false; |
| 10847 | } |
| 10848 | onStatus(buf) { |
| 10849 | this.statusText = buf.toString(); |
| 10850 | } |
| 10851 | onMessageBegin() { |
| 10852 | const { socket, client } = this; |
| 10853 | if (socket.destroyed) { |
| 10854 | return -1; |
| 10855 | } |
| 10856 | const request2 = client[kQueue][client[kRunningIdx]]; |
| 10857 | if (!request2) { |
| 10858 | return -1; |
| 10859 | } |
| 10860 | } |
| 10861 | onHeaderField(buf) { |
| 10862 | const len = this.headers.length; |
| 10863 | if ((len & 1) === 0) { |
| 10864 | this.headers.push(buf); |
| 10865 | } else { |
| 10866 | this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf]); |
| 10867 | } |
| 10868 | this.trackHeader(buf.length); |
| 10869 | } |
| 10870 | onHeaderValue(buf) { |
| 10871 | let len = this.headers.length; |
| 10872 | if ((len & 1) === 1) { |
| 10873 | this.headers.push(buf); |
| 10874 | len += 1; |
| 10875 | } else { |
| 10876 | this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf]); |
| 10877 | } |
| 10878 | const key = this.headers[len - 2]; |
| 10879 | if (key.length === 10 && key.toString().toLowerCase() === "keep-alive") { |
| 10880 | this.keepAlive += buf.toString(); |
| 10881 | } else if (key.length === 10 && key.toString().toLowerCase() === "connection") { |
| 10882 | this.connection += buf.toString(); |
| 10883 | } else if (key.length === 14 && key.toString().toLowerCase() === "content-length") { |
| 10884 | this.contentLength += buf.toString(); |
| 10885 | } |
| 10886 | this.trackHeader(buf.length); |
| 10887 | } |
| 10888 | trackHeader(len) { |
| 10889 | this.headersSize += len; |
| 10890 | if (this.headersSize >= this.headersMaxSize) { |
| 10891 | util.destroy(this.socket, new HeadersOverflowError()); |
| 10892 | } |
| 10893 | } |
| 10894 | onUpgrade(head) { |
| 10895 | const { upgrade, client, socket, headers, statusCode } = this; |
| 10896 | assert(upgrade); |
| 10897 | const request2 = client[kQueue][client[kRunningIdx]]; |
| 10898 | assert(request2); |
| 10899 | assert(!socket.destroyed); |
| 10900 | assert(socket === client[kSocket]); |
| 10901 | assert(!this.paused); |
| 10902 | assert(request2.upgrade || request2.method === "CONNECT"); |
| 10903 | this.statusCode = null; |
| 10904 | this.statusText = ""; |
| 10905 | this.shouldKeepAlive = null; |
| 10906 | assert(this.headers.length % 2 === 0); |
| 10907 | this.headers = []; |
| 10908 | this.headersSize = 0; |
| 10909 | socket.unshift(head); |
| 10910 | socket[kParser].destroy(); |
| 10911 | socket[kParser] = null; |
| 10912 | socket[kClient] = null; |
| 10913 | socket[kError] = null; |
| 10914 | socket.removeListener("error", onSocketError).removeListener("readable", onSocketReadable).removeListener("end", onSocketEnd).removeListener("close", onSocketClose); |
| 10915 | client[kSocket] = null; |
| 10916 | client[kQueue][client[kRunningIdx]++] = null; |
| 10917 | client.emit("disconnect", client[kUrl], [client], new InformationalError("upgrade")); |
| 10918 | try { |
| 10919 | request2.onUpgrade(statusCode, headers, socket); |
| 10920 | } catch (err) { |
| 10921 | util.destroy(socket, err); |
| 10922 | } |
| 10923 | resume(client); |
| 10924 | } |
| 10925 | onHeadersComplete(statusCode, upgrade, shouldKeepAlive) { |
| 10926 | const { client, socket, headers, statusText } = this; |
| 10927 | if (socket.destr |