text: /******/ (() => { // webpackBootstrap
  /******/ 	var __webpack_modules__ = ({
  
  /***/ 7351:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.issue = exports.issueCommand = void 0;
  const os = __importStar(__nccwpck_require__(2087));
  const utils_1 = __nccwpck_require__(5278);
  /**
   * Commands
   *
   * Command Format:
   *   ::name key=value,key=value::message
   *
   * Examples:
   *   ::warning::This is the message
   *   ::set-env name=MY_VAR::some value
   */
  function issueCommand(command, properties, message) {
      const cmd = new Command(command, properties, message);
      process.stdout.write(cmd.toString() + os.EOL);
  }
  exports.issueCommand = issueCommand;
  function issue(name, message = '') {
      issueCommand(name, {}, message);
  }
  exports.issue = issue;
  const CMD_STRING = '::';
  class Command {
      constructor(command, properties, message) {
          if (!command) {
              command = 'missing.command';
          }
          this.command = command;
          this.properties = properties;
          this.message = message;
      }
      toString() {
          let cmdStr = CMD_STRING + this.command;
          if (this.properties && Object.keys(this.properties).length > 0) {
              cmdStr += ' ';
              let first = true;
              for (const key in this.properties) {
                  if (this.properties.hasOwnProperty(key)) {
                      const val = this.properties[key];
                      if (val) {
                          if (first) {
                              first = false;
                          }
                          else {
                              cmdStr += ',';
                          }
                          cmdStr += `${key}=${escapeProperty(val)}`;
                      }
                  }
              }
          }
          cmdStr += `${CMD_STRING}${escapeData(this.message)}`;
          return cmdStr;
      }
  }
  function escapeData(s) {
      return utils_1.toCommandValue(s)
          .replace(/%/g, '%25')
          .replace(/\r/g, '%0D')
          .replace(/\n/g, '%0A');
  }
  function escapeProperty(s) {
      return utils_1.toCommandValue(s)
          .replace(/%/g, '%25')
          .replace(/\r/g, '%0D')
          .replace(/\n/g, '%0A')
          .replace(/:/g, '%3A')
          .replace(/,/g, '%2C');
  }
  //# sourceMappingURL=command.js.map
  
  /***/ }),
  
  /***/ 2186:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.getState = exports.saveState = exports.group = exports.endGroup = exports.startGroup = exports.info = exports.warning = exports.error = exports.debug = exports.isDebug = exports.setFailed = exports.setCommandEcho = exports.setOutput = exports.getBooleanInput = exports.getMultilineInput = exports.getInput = exports.addPath = exports.setSecret = exports.exportVariable = exports.ExitCode = void 0;
  const command_1 = __nccwpck_require__(7351);
  const file_command_1 = __nccwpck_require__(717);
  const utils_1 = __nccwpck_require__(5278);
  const os = __importStar(__nccwpck_require__(2087));
  const path = __importStar(__nccwpck_require__(5622));
  /**
   * The code to exit an action
   */
  var ExitCode;
  (function (ExitCode) {
      /**
       * A code indicating that the action was successful
       */
      ExitCode[ExitCode["Success"] = 0] = "Success";
      /**
       * A code indicating that the action was a failure
       */
      ExitCode[ExitCode["Failure"] = 1] = "Failure";
  })(ExitCode = exports.ExitCode || (exports.ExitCode = {}));
  //-----------------------------------------------------------------------
  // Variables
  //-----------------------------------------------------------------------
  /**
   * Sets env variable for this action and future actions in the job
   * @param name the name of the variable to set
   * @param val the value of the variable. Non-string values will be converted to a string via JSON.stringify
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  function exportVariable(name, val) {
      const convertedVal = utils_1.toCommandValue(val);
      process.env[name] = convertedVal;
      const filePath = process.env['GITHUB_ENV'] || '';
      if (filePath) {
          const delimiter = '_GitHubActionsFileCommandDelimeter_';
          const commandValue = `${name}<<${delimiter}${os.EOL}${convertedVal}${os.EOL}${delimiter}`;
          file_command_1.issueCommand('ENV', commandValue);
      }
      else {
          command_1.issueCommand('set-env', { name }, convertedVal);
      }
  }
  exports.exportVariable = exportVariable;
  /**
   * Registers a secret which will get masked from logs
   * @param secret value of the secret
   */
  function setSecret(secret) {
      command_1.issueCommand('add-mask', {}, secret);
  }
  exports.setSecret = setSecret;
  /**
   * Prepends inputPath to the PATH (for this action and future actions)
   * @param inputPath
   */
  function addPath(inputPath) {
      const filePath = process.env['GITHUB_PATH'] || '';
      if (filePath) {
          file_command_1.issueCommand('PATH', inputPath);
      }
      else {
          command_1.issueCommand('add-path', {}, inputPath);
      }
      process.env['PATH'] = `${inputPath}${path.delimiter}${process.env['PATH']}`;
  }
  exports.addPath = addPath;
  /**
   * Gets the value of an input.
   * Unless trimWhitespace is set to false in InputOptions, the value is also trimmed.
   * Returns an empty string if the value is not defined.
   *
   * @param     name     name of the input to get
   * @param     options  optional. See InputOptions.
   * @returns   string
   */
  function getInput(name, options) {
      const val = process.env[`INPUT_${name.replace(/ /g, '_').toUpperCase()}`] || '';
      if (options && options.required && !val) {
          throw new Error(`Input required and not supplied: ${name}`);
      }
      if (options && options.trimWhitespace === false) {
          return val;
      }
      return val.trim();
  }
  exports.getInput = getInput;
  /**
   * Gets the values of an multiline input.  Each value is also trimmed.
   *
   * @param     name     name of the input to get
   * @param     options  optional. See InputOptions.
   * @returns   string[]
   *
   */
  function getMultilineInput(name, options) {
      const inputs = getInput(name, options)
          .split('\n')
          .filter(x => x !== '');
      return inputs;
  }
  exports.getMultilineInput = getMultilineInput;
  /**
   * Gets the input value of the boolean type in the YAML 1.2 "core schema" specification.
   * Support boolean input list: `true | True | TRUE | false | False | FALSE` .
   * The return value is also in boolean type.
   * ref: https://yaml.org/spec/1.2/spec.html#id2804923
   *
   * @param     name     name of the input to get
   * @param     options  optional. See InputOptions.
   * @returns   boolean
   */
  function getBooleanInput(name, options) {
      const trueValue = ['true', 'True', 'TRUE'];
      const falseValue = ['false', 'False', 'FALSE'];
      const val = getInput(name, options);
      if (trueValue.includes(val))
          return true;
      if (falseValue.includes(val))
          return false;
      throw new TypeError(`Input does not meet YAML 1.2 "Core Schema" specification: ${name}\n` +
          `Support boolean input list: \`true | True | TRUE | false | False | FALSE\``);
  }
  exports.getBooleanInput = getBooleanInput;
  /**
   * Sets the value of an output.
   *
   * @param     name     name of the output to set
   * @param     value    value to store. Non-string values will be converted to a string via JSON.stringify
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  function setOutput(name, value) {
      process.stdout.write(os.EOL);
      command_1.issueCommand('set-output', { name }, value);
  }
  exports.setOutput = setOutput;
  /**
   * Enables or disables the echoing of commands into stdout for the rest of the step.
   * Echoing is disabled by default if ACTIONS_STEP_DEBUG is not set.
   *
   */
  function setCommandEcho(enabled) {
      command_1.issue('echo', enabled ? 'on' : 'off');
  }
  exports.setCommandEcho = setCommandEcho;
  //-----------------------------------------------------------------------
  // Results
  //-----------------------------------------------------------------------
  /**
   * Sets the action status to failed.
   * When the action exits it will be with an exit code of 1
   * @param message add error issue message
   */
  function setFailed(message) {
      process.exitCode = ExitCode.Failure;
      error(message);
  }
  exports.setFailed = setFailed;
  //-----------------------------------------------------------------------
  // Logging Commands
  //-----------------------------------------------------------------------
  /**
   * Gets whether Actions Step Debug is on or not
   */
  function isDebug() {
      return process.env['RUNNER_DEBUG'] === '1';
  }
  exports.isDebug = isDebug;
  /**
   * Writes debug message to user log
   * @param message debug message
   */
  function debug(message) {
      command_1.issueCommand('debug', {}, message);
  }
  exports.debug = debug;
  /**
   * Adds an error issue
   * @param message error issue message. Errors will be converted to string via toString()
   */
  function error(message) {
      command_1.issue('error', message instanceof Error ? message.toString() : message);
  }
  exports.error = error;
  /**
   * Adds an warning issue
   * @param message warning issue message. Errors will be converted to string via toString()
   */
  function warning(message) {
      command_1.issue('warning', message instanceof Error ? message.toString() : message);
  }
  exports.warning = warning;
  /**
   * Writes info to log with console.log.
   * @param message info message
   */
  function info(message) {
      process.stdout.write(message + os.EOL);
  }
  exports.info = info;
  /**
   * Begin an output group.
   *
   * Output until the next `groupEnd` will be foldable in this group
   *
   * @param name The name of the output group
   */
  function startGroup(name) {
      command_1.issue('group', name);
  }
  exports.startGroup = startGroup;
  /**
   * End an output group.
   */
  function endGroup() {
      command_1.issue('endgroup');
  }
  exports.endGroup = endGroup;
  /**
   * Wrap an asynchronous function call in a group.
   *
   * Returns the same type as the function itself.
   *
   * @param name The name of the group
   * @param fn The function to wrap in the group
   */
  function group(name, fn) {
      return __awaiter(this, void 0, void 0, function* () {
          startGroup(name);
          let result;
          try {
              result = yield fn();
          }
          finally {
              endGroup();
          }
          return result;
      });
  }
  exports.group = group;
  //-----------------------------------------------------------------------
  // Wrapper action state
  //-----------------------------------------------------------------------
  /**
   * Saves state for current action, the state can only be retrieved by this action's post job execution.
   *
   * @param     name     name of the state to store
   * @param     value    value to store. Non-string values will be converted to a string via JSON.stringify
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  function saveState(name, value) {
      command_1.issueCommand('save-state', { name }, value);
  }
  exports.saveState = saveState;
  /**
   * Gets the value of an state set by this action's main execution.
   *
   * @param     name     name of the state to get
   * @returns   string
   */
  function getState(name) {
      return process.env[`STATE_${name}`] || '';
  }
  exports.getState = getState;
  //# sourceMappingURL=core.js.map
  
  /***/ }),
  
  /***/ 717:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  // For internal use, subject to change.
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.issueCommand = void 0;
  // We use any as a valid input type
  /* eslint-disable @typescript-eslint/no-explicit-any */
  const fs = __importStar(__nccwpck_require__(5747));
  const os = __importStar(__nccwpck_require__(2087));
  const utils_1 = __nccwpck_require__(5278);
  function issueCommand(command, message) {
      const filePath = process.env[`GITHUB_${command}`];
      if (!filePath) {
          throw new Error(`Unable to find environment variable for file command ${command}`);
      }
      if (!fs.existsSync(filePath)) {
          throw new Error(`Missing file at path: ${filePath}`);
      }
      fs.appendFileSync(filePath, `${utils_1.toCommandValue(message)}${os.EOL}`, {
          encoding: 'utf8'
      });
  }
  exports.issueCommand = issueCommand;
  //# sourceMappingURL=file-command.js.map
  
  /***/ }),
  
  /***/ 5278:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  // We use any as a valid input type
  /* eslint-disable @typescript-eslint/no-explicit-any */
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.toCommandValue = void 0;
  /**
   * Sanitizes an input into a string so it can be passed into issueCommand safely
   * @param input input to sanitize into a string
   */
  function toCommandValue(input) {
      if (input === null || input === undefined) {
          return '';
      }
      else if (typeof input === 'string' || input instanceof String) {
          return input;
      }
      return JSON.stringify(input);
  }
  exports.toCommandValue = toCommandValue;
  //# sourceMappingURL=utils.js.map
  
  /***/ }),
  
  /***/ 5176:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.createFilter = void 0;
  const normalize_1 = __nccwpck_require__(7561);
  const util_1 = __nccwpck_require__(9735);
  function createFilter(options, ...args) {
      let criteria = args.length <= 1 ? args[0] : args;
      let filters = normalize_1.normalize(criteria, options);
      pathFilter[util_1._filters] = filters;
      return pathFilter;
      function pathFilter(...args) {
          // Does the file path match any of the exclude filters?
          let exclude = filters.exclude.some((filter) => filter(...args));
          if (exclude) {
              return false;
          }
          if (filters.include.length === 0) {
              // Include everything that's not excluded
              return true;
          }
          // Does the file path match any of the include filters?
          let include = filters.include.some((filter) => filter(...args));
          return include;
      }
  }
  exports.createFilter = createFilter;
  //# sourceMappingURL=create-filter.js.map
  
  /***/ }),
  
  /***/ 2405:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.filePathFilter = void 0;
  const create_filter_1 = __nccwpck_require__(5176);
  function filePathFilter(...args) {
      return create_filter_1.createFilter({}, ...args);
  }
  exports.filePathFilter = filePathFilter;
  //# sourceMappingURL=file-path-filter.js.map
  
  /***/ }),
  
  /***/ 3410:
  /***/ (function(module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __exportStar = (this && this.__exportStar) || function(m, exports) {
      for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.filePathFilter = void 0;
  const file_path_filter_1 = __nccwpck_require__(2405);
  Object.defineProperty(exports, "filePathFilter", ({ enumerable: true, get: function () { return file_path_filter_1.filePathFilter; } }));
  __exportStar(__nccwpck_require__(3225), exports);
  var create_filter_1 = __nccwpck_require__(5176);
  Object.defineProperty(exports, "createFilter", ({ enumerable: true, get: function () { return create_filter_1.createFilter; } }));
  // Export `filePathFilter` as a named export and the default export
  exports.default = file_path_filter_1.filePathFilter;
  // CommonJS default export hack
  /* eslint-env commonjs */
  if ( true && typeof module.exports === "object") {
      module.exports = Object.assign(module.exports.default, module.exports);
  }
  //# sourceMappingURL=index.js.map
  
  /***/ }),
  
  /***/ 7561:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.normalize = void 0;
  const globToRegExp = __nccwpck_require__(7117);
  const path = __nccwpck_require__(5622);
  const util_1 = __nccwpck_require__(9735);
  /**
   * Normalizes the user-provided filter criteria. The normalized form is a `Filters` object
   * whose `include` and `exclude` properties are both `FilterFunction` arrays.
   */
  function normalize(criteria, opts) {
      let filters = {
          include: [],
          exclude: [],
      };
      let options = normalizeOptions(opts);
      // Convert each criterion to a FilterFunction
      let tuples = normalizeCriteria(criteria, options);
      // Populate the `include` and `exclude` arrays
      for (let [filter, filterFunction] of tuples) {
          filters[filter].push(filterFunction);
      }
      return filters;
  }
  exports.normalize = normalize;
  /**
   * Fills-in defaults for any options that weren't specified by the caller.
   */
  function normalizeOptions(options) {
      return {
          // TODO: Remove the "getPath" fallback in the next minor release
          map: options.map || options.getPath || String,
          sep: options.sep || path.sep,
      };
  }
  /**
   * Creates a `FilterFunction` for each given criterion.
   */
  function normalizeCriteria(criteria, options, filter) {
      let tuples = [];
      if (Array.isArray(criteria)) {
          for (let criterion of criteria) {
              tuples.push(...normalizeCriteria(criterion, options, filter));
          }
      }
      else if (util_1.isPathFilter(criteria)) {
          for (let filterFunction of criteria[util_1._filters].include) {
              tuples.push(["include", filterFunction]);
          }
          for (let filterFunction of criteria[util_1._filters].exclude) {
              tuples.push(["exclude", filterFunction]);
          }
      }
      else if (util_1.isFilterCriterion(criteria)) {
          tuples.push(normalizeCriterion(criteria, options, filter));
      }
      else if (criteria && typeof criteria === "object" && !filter) {
          if (criteria.include !== undefined) {
              tuples.push(...normalizeCriteria(criteria.include, options, "include"));
          }
          if (criteria.exclude !== undefined) {
              tuples.push(...normalizeCriteria(criteria.exclude, options, "exclude"));
          }
      }
      else {
          throw new Error(`Invalid filter criteria: ${criteria}`);
      }
      return tuples;
  }
  /**
   * Creates a `FilterFunction` for the given criterion.
   *
   * @param criteria - One or more filter critiera
   * @param options - Options for how the `FilterFunction` should behave
   * @param filter - The type of filter. Defaults to `include`, except for glob patterns that start with "!"
   */
  function normalizeCriterion(criterion, options, filter) {
      const globOptions = { extended: true, globstar: true };
      let type = typeof criterion;
      let filterFunction;
      if (type === "function") {
          filterFunction = criterion;
      }
      else if (type === "boolean") {
          let bool = criterion;
          filterFunction = function booleanFilter() {
              return bool;
          };
      }
      else if (type === "string") {
          let glob = criterion;
          let invert = false;
          if (glob.startsWith("!")) {
              glob = glob.substr(1);
              invert = Boolean(filter);
              filter = filter || "exclude";
          }
          let pattern = globToRegExp(glob, globOptions);
          filterFunction = createGlobFilter(pattern, options, invert);
      }
      else if (criterion instanceof RegExp) {
          let pattern = criterion;
          let { map } = options;
          filterFunction = function regExpFilter(...args) {
              let filePath = map(...args);
              return pattern.test(filePath);
          };
      }
      else {
          throw new Error(`Invalid filter criteria: ${criterion}`);
      }
      return [filter || "include", filterFunction];
  }
  /**
   * Creates a `FilterFunction` for filtering based on glob patterns
   */
  function createGlobFilter(pattern, options, invert) {
      let { map, sep } = options;
      return function globFilter(...args) {
          let filePath = map(...args);
          if (sep !== "/") {
              // Glob patterns always expect forward slashes, even on Windows
              filePath = filePath.replace(new RegExp("\\" + sep, "g"), "/");
          }
          let match = pattern.test(filePath);
          return invert ? !match : match;
      };
  }
  //# sourceMappingURL=normalize.js.map
  
  /***/ }),
  
  /***/ 3225:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  //# sourceMappingURL=types.js.map
  
  /***/ }),
  
  /***/ 9735:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.isPathFilter = exports.isFilterCriterion = exports._filters = void 0;
  /**
   * Symbol used to store the underlying filters of a `pathFilter()` function.
   */
  exports._filters = Symbol("_filters");
  /**
   * Determines whether the given value is a `FilterCriterion`.
   */
  function isFilterCriterion(value) {
      let type = typeof value;
      return type === "string" ||
          type === "boolean" ||
          type === "function" ||
          value instanceof RegExp;
  }
  exports.isFilterCriterion = isFilterCriterion;
  /**
   * Determines whether the given value is one of our internal `pathFilter()` functions.
   */
  function isPathFilter(value) {
      let fn = value;
      return fn &&
          typeof fn === "function" &&
          typeof fn[exports._filters] === "object";
  }
  exports.isPathFilter = isPathFilter;
  //# sourceMappingURL=util.js.map
  
  /***/ }),
  
  /***/ 504:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.asyncForEach = void 0;
  /**
   * Simultaneously processes all items in the given array.
   *
   * @param array - The array to iterate over
   * @param iterator - The function to call for each item in the array
   * @param done - The function to call when all iterators have completed
   *
   * @internal
   */
  function asyncForEach(array, iterator, done) {
      if (!Array.isArray(array)) {
          throw new TypeError(`${array} is not an array`);
      }
      if (array.length === 0) {
          // NOTE: Normally a bad idea to mix sync and async, but it's safe here because
          // of the way that this method is currently used by DirectoryReader.
          done();
          return;
      }
      // Simultaneously process all items in the array.
      let pending = array.length;
      for (let item of array) {
          iterator(item, callback);
      }
      function callback() {
          if (--pending === 0) {
              done();
          }
      }
  }
  exports.asyncForEach = asyncForEach;
  //# sourceMappingURL=for-each.js.map
  
  /***/ }),
  
  /***/ 5833:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.readdirAsync = void 0;
  const fs = __nccwpck_require__(5747);
  const directory_reader_1 = __nccwpck_require__(4918);
  const for_each_1 = __nccwpck_require__(504);
  const asyncFacade = { fs, forEach: for_each_1.asyncForEach };
  function readdirAsync(dir, options, callback) {
      if (typeof options === "function") {
          callback = options;
          options = undefined;
      }
      let promise = new Promise((resolve, reject) => {
          let results = [];
          let reader = new directory_reader_1.DirectoryReader(dir, options, asyncFacade);
          let stream = reader.stream;
          stream.on("error", (err) => {
              reject(err);
              stream.pause();
          });
          stream.on("data", (result) => {
              results.push(result);
          });
          stream.on("end", () => {
              resolve(results);
          });
      });
      if (callback) {
          promise.then((results) => callback(null, results), (err) => callback(err, undefined));
      }
      else {
          return promise;
      }
  }
  exports.readdirAsync = readdirAsync;
  //# sourceMappingURL=index.js.map
  
  /***/ }),
  
  /***/ 8188:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.callOnce = exports.safeCall = void 0;
  /**
   * Calls a function with the given arguments, and ensures that the error-first callback is _always_
   * invoked exactly once, even if the function throws an error.
   *
   * @param fn - The function to invoke
   * @param args - The arguments to pass to the function. The final argument must be a callback function.
   *
   * @internal
   */
  function safeCall(fn, input, callback) {
      // Replace the callback function with a wrapper that ensures it will only be called once
      callback = callOnce(callback);
      try {
          fn(input, callback);
      }
      catch (err) {
          callback(err, undefined);
      }
  }
  exports.safeCall = safeCall;
  /**
   * Returns a wrapper function that ensures the given callback function is only called once.
   * Subsequent calls are ignored, unless the first argument is an Error, in which case the
   * error is thrown.
   *
   * @param callback - The function that should only be called once
   *
   * @internal
   */
  function callOnce(callback) {
      let fulfilled = false;
      return function onceWrapper(err, result) {
          if (!fulfilled) {
              fulfilled = true;
              callback.call(this, err, result);
          }
          else if (err) {
              // The callback has already been called, but now an error has occurred
              // (most likely inside the callback function). So re-throw the error,
              // so it gets handled further up the call stack
              throw err;
          }
      };
  }
  exports.callOnce = callOnce;
  //# sourceMappingURL=call.js.map
  
  /***/ }),
  
  /***/ 4918:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.DirectoryReader = void 0;
  const path = __nccwpck_require__(5622);
  const stream_1 = __nccwpck_require__(2413);
  const call_1 = __nccwpck_require__(8188);
  const normalize_options_1 = __nccwpck_require__(2977);
  const stat_1 = __nccwpck_require__(9445);
  /**
   * Asynchronously reads the contents of a directory and streams the results
   * via a `ReadableStream`.
   *
   * @internal
   */
  class DirectoryReader {
      /**
       * @param dir - The absolute or relative directory path to read
       * @param [options] - User-specified options, if any (see `normalizeOptions()`)
       * @param facade - sync or async function implementations
       * @param emit - Indicates whether the reader should emit "file", "directory", and "symlink" events.
       */
      constructor(dir, options, facade, emit = false) {
          this.options = normalize_options_1.normalizeOptions(options, facade, emit);
          // Indicates whether we should keep reading
          // This is set false if stream.Readable.push() returns false.
          this.shouldRead = true;
          // The directories to read
          // (initialized with the top-level directory)
          this.queue = [{
                  path: dir,
                  basePath: this.options.basePath,
                  depth: 0
              }];
          // The number of directories that are currently being processed
          this.pending = 0;
          // The data that has been read, but not yet emitted
          this.buffer = [];
          this.stream = new stream_1.Readable({ objectMode: true });
          this.stream._read = () => {
              // Start (or resume) reading
              this.shouldRead = true;
              // If we have data in the buffer, then send the next chunk
              if (this.buffer.length > 0) {
                  this.pushFromBuffer();
              }
              // If we have directories queued, then start processing the next one
              if (this.queue.length > 0) {
                  this.readNextDirectory();
              }
              this.checkForEOF();
          };
      }
      /**
       * Reads the next directory in the queue
       */
      readNextDirectory() {
          let { facade } = this.options;
          let dir = this.queue.shift();
          this.pending++;
          // Read the directory listing
          call_1.safeCall(facade.fs.readdir, dir.path, (err, items) => {
              if (err) {
                  // fs.readdir threw an error
                  this.emit("error", err);
                  return this.finishedReadingDirectory();
              }
              try {
                  // Process each item in the directory (simultaneously, if async)
                  facade.forEach(items, this.processItem.bind(this, dir), this.finishedReadingDirectory.bind(this, dir));
              }
              catch (err2) {
                  // facade.forEach threw an error
                  // (probably because fs.readdir returned an invalid result)
                  this.emit("error", err2);
                  this.finishedReadingDirectory();
              }
          });
      }
      /**
       * This method is called after all items in a directory have been processed.
       *
       * NOTE: This does not necessarily mean that the reader is finished, since there may still
       * be other directories queued or pending.
       */
      finishedReadingDirectory() {
          this.pending--;
          if (this.shouldRead) {
              // If we have directories queued, then start processing the next one
              if (this.queue.length > 0) {
                  this.readNextDirectory();
              }
              this.checkForEOF();
          }
      }
      /**
       * Determines whether the reader has finished processing all items in all directories.
       * If so, then the "end" event is fired (via {@Readable#push})
       */
      checkForEOF() {
          if (this.buffer.length === 0 && // The stuff we've already read
              this.pending === 0 && // The stuff we're currently reading
              this.queue.length === 0) { // The stuff we haven't read yet
              // There's no more stuff!
              this.stream.push(null);
          }
      }
      /**
       * Processes a single item in a directory.
       *
       * If the item is a directory, and `option.deep` is enabled, then the item will be added
       * to the directory queue.
       *
       * If the item meets the filter criteria, then it will be emitted to the reader's stream.
       *
       * @param dir - A directory object from the queue
       * @param item - The name of the item (name only, no path)
       * @param done - A callback function that is called after the item has been processed
       */
      processItem(dir, item, done) {
          let stream = this.stream;
          let options = this.options;
          let itemPath = dir.basePath + item;
          let fullPath = path.join(dir.path, item);
          // If `options.deep` is a number, and we've already recursed to the max depth,
          // then there's no need to check fs.Stats to know if it's a directory.
          // If `options.deep` is a function, then we'll need fs.Stats
          let maxDepthReached = dir.depth >= options.recurseDepth;
          // Do we need to call `fs.stat`?
          let needStats = !maxDepthReached || // we need the fs.Stats to know if it's a directory
              options.stats || // the user wants fs.Stats objects returned
              options.recurseFnNeedsStats || // we need fs.Stats for the recurse function
              options.filterFnNeedsStats || // we need fs.Stats for the filter function
              stream.listenerCount("file") || // we need the fs.Stats to know if it's a file
              stream.listenerCount("directory") || // we need the fs.Stats to know if it's a directory
              stream.listenerCount("symlink"); // we need the fs.Stats to know if it's a symlink
          // If we don't need stats, then exit early
          if (!needStats) {
              if (this.filter({ path: itemPath })) {
                  this.pushOrBuffer({ data: itemPath });
              }
              return done();
          }
          // Get the fs.Stats object for this path
          stat_1.stat(options.facade.fs, fullPath, (err, stats) => {
              if (err) {
                  // fs.stat threw an error
                  this.emit("error", err);
                  return done();
              }
              try {
                  // Add the item's path to the fs.Stats object
                  // The base of this path, and its separators are determined by the options
                  // (i.e. options.basePath and options.sep)
                  stats.path = itemPath;
                  // Add depth of the path to the fs.Stats object for use this in the filter function
                  stats.depth = dir.depth;
                  if (this.shouldRecurse(stats, maxDepthReached)) {
                      // Add this subdirectory to the queue
                      this.queue.push({
                          path: fullPath,
                          basePath: itemPath + options.sep,
                          depth: dir.depth + 1,
                      });
                  }
                  // Determine whether this item matches the filter criteria
                  if (this.filter(stats)) {
                      this.pushOrBuffer({
                          data: options.stats ? stats : itemPath,
                          file: stats.isFile(),
                          directory: stats.isDirectory(),
                          symlink: stats.isSymbolicLink(),
                      });
                  }
                  done();
              }
              catch (err2) {
                  // An error occurred while processing the item
                  // (probably during a user-specified function, such as options.deep, options.filter, etc.)
                  this.emit("error", err2);
                  done();
              }
          });
      }
      /**
       * Pushes the given chunk of data to the stream, or adds it to the buffer,
       * depending on the state of the stream.
       */
      pushOrBuffer(chunk) {
          // Add the chunk to the buffer
          this.buffer.push(chunk);
          // If we're still reading, then immediately emit the next chunk in the buffer
          // (which may or may not be the chunk that we just added)
          if (this.shouldRead) {
              this.pushFromBuffer();
          }
      }
      /**
       * Immediately pushes the next chunk in the buffer to the reader's stream.
       * The "data" event will always be fired (via `Readable.push()`).
       * In addition, the "file", "directory", and/or "symlink" events may be fired,
       * depending on the type of properties of the chunk.
       */
      pushFromBuffer() {
          let stream = this.stream;
          let chunk = this.buffer.shift();
          // Stream the data
          try {
              this.shouldRead = stream.push(chunk.data);
          }
          catch (err) {
              this.emit("error", err);
          }
          if (this.options.emit) {
              // Also emit specific events, based on the type of chunk
              chunk.file && this.emit("file", chunk.data);
              chunk.symlink && this.emit("symlink", chunk.data);
              chunk.directory && this.emit("directory", chunk.data);
          }
      }
      /**
       * Determines whether the given directory meets the user-specified recursion criteria.
       * If the user didn't specify recursion criteria, then this function will default to true.
       *
       * @param stats - The directory's `Stats` object
       * @param maxDepthReached - Whether we've already crawled the user-specified depth
       */
      shouldRecurse(stats, maxDepthReached) {
          let { recurseFn } = this.options;
          if (maxDepthReached) {
              // We've already crawled to the maximum depth. So no more recursion.
              return false;
          }
          else if (!stats.isDirectory()) {
              // It's not a directory. So don't try to crawl it.
              return false;
          }
          else if (recurseFn) {
              try {
                  // Run the user-specified recursion criteria
                  return !!recurseFn(stats);
              }
              catch (err) {
                  // An error occurred in the user's code.
                  // In Sync and Async modes, this will return an error.
                  // In Streaming mode, we emit an "error" event, but continue processing
                  this.emit("error", err);
              }
          }
          else {
              // No recursion function was specified, and we're within the maximum depth.
              // So crawl this directory.
              return true;
          }
      }
      /**
       * Determines whether the given item meets the user-specified filter criteria.
       * If the user didn't specify a filter, then this function will always return true.
       *
       * @param stats - The item's `Stats` object, or an object with just a `path` property
       */
      filter(stats) {
          let { filterFn } = this.options;
          if (filterFn) {
              try {
                  // Run the user-specified filter function
                  return !!filterFn(stats);
              }
              catch (err) {
                  // An error occurred in the user's code.
                  // In Sync and Async modes, this will return an error.
                  // In Streaming mode, we emit an "error" event, but continue processing
                  this.emit("error", err);
              }
          }
          else {
              // No filter was specified, so match everything
              return true;
          }
      }
      /**
       * Emits an event.  If one of the event listeners throws an error,
       * then an "error" event is emitted.
       */
      emit(eventName, data) {
          let stream = this.stream;
          try {
              stream.emit(eventName, data);
          }
          catch (err) {
              if (eventName === "error") {
                  // Don't recursively emit "error" events.
                  // If the first one fails, then just throw
                  throw err;
              }
              else {
                  stream.emit("error", err);
              }
          }
      }
  }
  exports.DirectoryReader = DirectoryReader;
  //# sourceMappingURL=directory-reader.js.map
  
  /***/ }),
  
  /***/ 8811:
  /***/ (function(module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __exportStar = (this && this.__exportStar) || function(m, exports) {
      for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.readdir = void 0;
  const async_1 = __nccwpck_require__(5833);
  const iterator_1 = __nccwpck_require__(5944);
  const stream_1 = __nccwpck_require__(5521);
  const sync_1 = __nccwpck_require__(704);
  const readdir = async_1.readdirAsync;
  exports.readdir = readdir;
  readdir.sync = sync_1.readdirSync;
  readdir.async = async_1.readdirAsync;
  readdir.stream = stream_1.readdirStream;
  readdir.iterator = iterator_1.readdirIterator;
  var async_2 = __nccwpck_require__(5833);
  Object.defineProperty(exports, "readdirAsync", ({ enumerable: true, get: function () { return async_2.readdirAsync; } }));
  var iterator_2 = __nccwpck_require__(5944);
  Object.defineProperty(exports, "readdirIterator", ({ enumerable: true, get: function () { return iterator_2.readdirIterator; } }));
  var stream_2 = __nccwpck_require__(5521);
  Object.defineProperty(exports, "readdirStream", ({ enumerable: true, get: function () { return stream_2.readdirStream; } }));
  var sync_2 = __nccwpck_require__(704);
  Object.defineProperty(exports, "readdirSync", ({ enumerable: true, get: function () { return sync_2.readdirSync; } }));
  __exportStar(__nccwpck_require__(6299), exports);
  exports.default = readdir;
  // CommonJS default export hack
  /* eslint-env commonjs */
  if ( true && typeof module.exports === "object") {
      module.exports = Object.assign(module.exports.default, module.exports);
  }
  //# sourceMappingURL=index.js.map
  
  /***/ }),
  
  /***/ 5944:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.readdirIterator = void 0;
  const fs = __nccwpck_require__(5747);
  const for_each_1 = __nccwpck_require__(504);
  const directory_reader_1 = __nccwpck_require__(4918);
  const pending_1 = __nccwpck_require__(8553);
  const iteratorFacade = { fs, forEach: for_each_1.asyncForEach };
  function readdirIterator(dir, options) {
      let reader = new directory_reader_1.DirectoryReader(dir, options, iteratorFacade);
      let stream = reader.stream;
      let pendingValues = [];
      let pendingReads = [];
      let error;
      let readable = false;
      let done = false;
      stream.on("error", function streamError(err) {
          error = err;
          stream.pause();
          fulfillPendingReads();
      });
      stream.on("end", function streamEnd() {
          done = true;
          fulfillPendingReads();
      });
      stream.on("readable", function streamReadable() {
          readable = true;
          fulfillPendingReads();
      });
      return {
          [Symbol.asyncIterator]() {
              return this;
          },
          next() {
              let pendingRead = pending_1.pending();
              pendingReads.push(pendingRead);
              // eslint-disable-next-line @typescript-eslint/no-floating-promises
              Promise.resolve().then(fulfillPendingReads);
              return pendingRead.promise;
          }
      };
      function fulfillPendingReads() {
          if (error) {
              while (pendingReads.length > 0) {
                  let pendingRead = pendingReads.shift();
                  pendingRead.reject(error);
              }
          }
          else if (pendingReads.length > 0) {
              while (pendingReads.length > 0) {
                  let pendingRead = pendingReads.shift();
                  let value = getNextValue();
                  if (value) {
                      pendingRead.resolve({ value });
                  }
                  else if (done) {
                      pendingRead.resolve({ done, value });
                  }
                  else {
                      pendingReads.unshift(pendingRead);
                      break;
                  }
              }
          }
      }
      function getNextValue() {
          let value = pendingValues.shift();
          if (value) {
              return value;
          }
          else if (readable) {
              readable = false;
              while (true) {
                  value = stream.read();
                  if (value) {
                      pendingValues.push(value);
                  }
                  else {
                      break;
                  }
              }
              return pendingValues.shift();
          }
      }
  }
  exports.readdirIterator = readdirIterator;
  //# sourceMappingURL=index.js.map
  
  /***/ }),
  
  /***/ 8553:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.pending = void 0;
  /**
   * Returns a `Promise` and the functions to resolve or reject it.
   * @internal
   */
  function pending() {
      let resolve, reject;
      let promise = new Promise((res, rej) => {
          resolve = res;
          reject = rej;
      });
      return {
          promise,
          resolve(result) {
              // eslint-disable-next-line @typescript-eslint/no-floating-promises
              Promise.resolve(result).then(resolve);
          },
          reject(reason) {
              Promise.reject(reason).catch(reject);
          }
      };
  }
  exports.pending = pending;
  //# sourceMappingURL=pending.js.map
  
  /***/ }),
  
  /***/ 2977:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.normalizeOptions = void 0;
  const file_path_filter_1 = __nccwpck_require__(3410);
  const path = __nccwpck_require__(5622);
  /**
   * Validates and normalizes the options argument
   *
   * @param [options] - User-specified options, if any
   * @param facade - sync or async function implementations
   * @param emit - Indicates whether the reader should emit "file", "directory", and "symlink" events.
   *
   * @internal
   */
  function normalizeOptions(options, facade, emit) {
      if (options === null || options === undefined) {
          options = {};
      }
      else if (typeof options !== "object") {
          throw new TypeError("options must be an object");
      }
      let sep = options.sep;
      if (sep === null || sep === undefined) {
          sep = path.sep;
      }
      else if (typeof sep !== "string") {
          throw new TypeError("options.sep must be a string");
      }
      let stats = Boolean(options.stats || options.withFileTypes);
      let recurseDepth, recurseFn, recurseFnNeedsStats = false, deep = options.deep;
      if (deep === null || deep === undefined) {
          recurseDepth = 0;
      }
      else if (typeof deep === "boolean") {
          recurseDepth = deep ? Infinity : 0;
      }
      else if (typeof deep === "number") {
          if (deep < 0 || isNaN(deep)) {
              throw new Error("options.deep must be a positive number");
          }
          else if (Math.floor(deep) !== deep) {
              throw new Error("options.deep must be an integer");
          }
          else {
              recurseDepth = deep;
          }
      }
      else if (typeof deep === "function") {
          // Recursion functions require a Stats object
          recurseFnNeedsStats = true;
          recurseDepth = Infinity;
          recurseFn = deep;
      }
      else if (deep instanceof RegExp || (typeof deep === "string" && deep.length > 0)) {
          recurseDepth = Infinity;
          recurseFn = file_path_filter_1.createFilter({ map, sep }, deep);
      }
      else {
          throw new TypeError("options.deep must be a boolean, number, function, regular expression, or glob pattern");
      }
      let filterFn, filterFnNeedsStats = false, filter = options.filter;
      if (filter !== null && filter !== undefined) {
          if (typeof filter === "function") {
              // Filter functions requres a Stats object
              filterFnNeedsStats = true;
              filterFn = filter;
          }
          else if (filter instanceof RegExp ||
              typeof filter === "boolean" ||
              (typeof filter === "string" && filter.length > 0)) {
              filterFn = file_path_filter_1.createFilter({ map, sep }, filter);
          }
          else {
              throw new TypeError("options.filter must be a boolean, function, regular expression, or glob pattern");
          }
      }
      let basePath = options.basePath;
      if (basePath === null || basePath === undefined) {
          basePath = "";
      }
      else if (typeof basePath === "string") {
          // Append a path separator to the basePath, if necessary
          if (basePath && basePath.substr(-1) !== sep) {
              basePath += sep;
          }
      }
      else {
          throw new TypeError("options.basePath must be a string");
      }
      // Determine which facade methods to use
      if (options.fs === null || options.fs === undefined) {
          // The user didn't provide their own facades, so use our internal ones
      }
      else if (typeof options.fs === "object") {
          // Merge the internal facade methods with the user-provided `fs` facades
          facade = Object.assign({}, facade);
          facade.fs = Object.assign({}, facade.fs, options.fs);
      }
      else {
          throw new TypeError("options.fs must be an object");
      }
      return {
          recurseDepth,
          recurseFn,
          recurseFnNeedsStats,
          filterFn,
          filterFnNeedsStats,
          stats,
          sep,
          basePath,
          facade,
          emit,
      };
  }
  exports.normalizeOptions = normalizeOptions;
  /**
   * Maps our modified fs.Stats objects to file paths
   */
  function map(stats) {
      return stats.path;
  }
  //# sourceMappingURL=normalize-options.js.map
  
  /***/ }),
  
  /***/ 9445:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.stat = void 0;
  const call_1 = __nccwpck_require__(8188);
  /**
   * Retrieves the `Stats` for the given path. If the path is a symbolic link,
   * then the Stats of the symlink's target are returned instead.  If the symlink is broken,
   * then the Stats of the symlink itself are returned.
   *
   * @param fs - Synchronous or Asynchronouse facade for the "fs" module
   * @param path - The path to return stats for
   *
   * @internal
   */
  function stat(fs, path, callback) {
      let isSymLink = false;
      call_1.safeCall(fs.lstat, path, (err, lstats) => {
          if (err) {
              // fs.lstat threw an eror
              return callback(err, undefined);
          }
          try {
              isSymLink = lstats.isSymbolicLink();
          }
          catch (err2) {
              // lstats.isSymbolicLink() threw an error
              // (probably because fs.lstat returned an invalid result)
              return callback(err2, undefined);
          }
          if (isSymLink) {
              // Try to resolve the symlink
              symlinkStat(fs, path, lstats, callback);
          }
          else {
              // It's not a symlink, so return the stats as-is
              callback(null, lstats);
          }
      });
  }
  exports.stat = stat;
  /**
   * Retrieves the `Stats` for the target of the given symlink.
   * If the symlink is broken, then the Stats of the symlink itself are returned.
   *
   * @param fs - Synchronous or Asynchronouse facade for the "fs" module
   * @param path - The path of the symlink to return stats for
   * @param lstats - The stats of the symlink
   */
  function symlinkStat(fs, path, lstats, callback) {
      call_1.safeCall(fs.stat, path, (err, stats) => {
          if (err) {
              // The symlink is broken, so return the stats for the link itself
              return callback(null, lstats);
          }
          try {
              // Return the stats for the resolved symlink target,
              // and override the `isSymbolicLink` method to indicate that it's a symlink
              stats.isSymbolicLink = () => true;
          }
          catch (err2) {
              // Setting stats.isSymbolicLink threw an error
              // (probably because fs.stat returned an invalid result)
              return callback(err2, undefined);
          }
          callback(null, stats);
      });
  }
  //# sourceMappingURL=stat.js.map
  
  /***/ }),
  
  /***/ 5521:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.readdirStream = void 0;
  const fs = __nccwpck_require__(5747);
  const for_each_1 = __nccwpck_require__(504);
  const directory_reader_1 = __nccwpck_require__(4918);
  const streamFacade = { fs, forEach: for_each_1.asyncForEach };
  function readdirStream(dir, options) {
      let reader = new directory_reader_1.DirectoryReader(dir, options, streamFacade, true);
      return reader.stream;
  }
  exports.readdirStream = readdirStream;
  //# sourceMappingURL=index.js.map
  
  /***/ }),
  
  /***/ 7448:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.syncForEach = void 0;
  /**
   * A facade that allows `Array.forEach()` to be called as though it were asynchronous.
   *
   * @param array - The array to iterate over
   * @param iterator - The function to call for each item in the array
   * @param done - The function to call when all iterators have completed
   *
   * @internal
   */
  function syncForEach(array, iterator, done) {
      if (!Array.isArray(array)) {
          throw new TypeError(`${array} is not an array`);
      }
      for (let item of array) {
          iterator(item, () => {
              // Note: No error-handling here because this is currently only ever called
              // by DirectoryReader, which never passes an `error` parameter to the callback.
              // Instead, DirectoryReader emits an "error" event if an error occurs.
          });
      }
      done();
  }
  exports.syncForEach = syncForEach;
  //# sourceMappingURL=for-each.js.map
  
  /***/ }),
  
  /***/ 3073:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.syncFS = void 0;
  const fs = __nccwpck_require__(5747);
  const call_1 = __nccwpck_require__(8188);
  /**
   * Synchronous versions of `fs` methods.
   *
   * @internal
   */
  exports.syncFS = {
      /**
       * A facade around `fs.readdirSync()` that allows it to be called
       * the same way as `fs.readdir()`.
       */
      readdir(dir, callback) {
          // Make sure the callback is only called once
          callback = call_1.callOnce(callback);
          try {
              let items = fs.readdirSync(dir);
              callback(null, items);
          }
          catch (err) {
              callback(err, undefined);
          }
      },
      /**
       * A facade around `fs.statSync()` that allows it to be called
       * the same way as `fs.stat()`.
       */
      stat(path, callback) {
          // Make sure the callback is only called once
          callback = call_1.callOnce(callback);
          try {
              let stats = fs.statSync(path);
              callback(null, stats);
          }
          catch (err) {
              callback(err, undefined);
          }
      },
      /**
       * A facade around `fs.lstatSync()` that allows it to be called
       * the same way as `fs.lstat()`.
       */
      lstat(path, callback) {
          // Make sure the callback is only called once
          callback = call_1.callOnce(callback);
          try {
              let stats = fs.lstatSync(path);
              callback(null, stats);
          }
          catch (err) {
              callback(err, undefined);
          }
      },
  };
  //# sourceMappingURL=fs.js.map
  
  /***/ }),
  
  /***/ 704:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.readdirSync = void 0;
  const directory_reader_1 = __nccwpck_require__(4918);
  const for_each_1 = __nccwpck_require__(7448);
  const fs_1 = __nccwpck_require__(3073);
  const syncFacade = { fs: fs_1.syncFS, forEach: for_each_1.syncForEach };
  function readdirSync(dir, options) {
      let reader = new directory_reader_1.DirectoryReader(dir, options, syncFacade);
      let stream = reader.stream;
      let results = [];
      let data = stream.read();
      while (data !== null) {
          results.push(data);
          data = stream.read();
      }
      return results;
  }
  exports.readdirSync = readdirSync;
  //# sourceMappingURL=index.js.map
  
  /***/ }),
  
  /***/ 6299:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  //# sourceMappingURL=types-public.js.map
  
  /***/ }),
  
  /***/ 9946:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  };
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.HashDiff = exports.fileHash = void 0;
  const fs_1 = __importDefault(__nccwpck_require__(5747));
  const crypto_1 = __importDefault(__nccwpck_require__(6417));
  function formatNumber(number) {
      return number.toLocaleString();
  }
  function fileHash(filename, algorithm) {
      return __awaiter(this, void 0, void 0, function* () {
          return new Promise((resolve, reject) => {
              // Algorithm depends on availability of OpenSSL on platform
              // Another algorithms: "sha1", "md5", "sha256", "sha512" ...
              let shasum = crypto_1.default.createHash(algorithm);
              try {
                  let s = fs_1.default.createReadStream(filename);
                  s.on("data", function (data) {
                      shasum.update(data);
                  });
                  s.on("error", function (error) {
                      reject(error);
                  });
                  // making digest
                  s.on("end", function () {
                      const hash = shasum.digest("hex");
                      return resolve(hash);
                  });
              }
              catch (error) {
                  return reject("calc fail");
              }
          });
      });
  }
  exports.fileHash = fileHash;
  class HashDiff {
      getDiffs(localFiles, serverFiles, logger) {
          var _a, _b, _c;
          const uploadList = [];
          const deleteList = [];
          const replaceList = [];
          let sizeUpload = 0;
          let sizeDelete = 0;
          let sizeReplace = 0;
          // alphabetize each list based off path
          const localFilesSorted = localFiles.data.sort((first, second) => first.name.localeCompare(second.name));
          const serverFilesSorted = serverFiles.data.sort((first, second) => first.name.localeCompare(second.name));
          logger.standard(`----------------------------------------------------------------`);
          logger.standard(`Local Files:\t${formatNumber(localFilesSorted.length)}`);
          logger.standard(`Server Files:\t${formatNumber(localFilesSorted.length)}`);
          logger.standard(`----------------------------------------------------------------`);
          logger.standard(`Calculating differences between client & server`);
          logger.standard(`----------------------------------------------------------------`);
          let localPosition = 0;
          let serverPosition = 0;
          while (localPosition + serverPosition < localFilesSorted.length + serverFilesSorted.length) {
              let localFile = localFilesSorted[localPosition];
              let serverFile = serverFilesSorted[serverPosition];
              let fileNameCompare = 0;
              if (localFile === undefined) {
                  fileNameCompare = 1;
              }
              if (serverFile === undefined) {
                  fileNameCompare = -1;
              }
              if (localFile !== undefined && serverFile !== undefined) {
                  fileNameCompare = localFile.name.localeCompare(serverFile.name);
              }
              if (fileNameCompare < 0) {
                  let icon = localFile.type === "folder" ? `📁 Create` : `➕ Upload`;
                  logger.standard(`${icon}: ${localFile.name}`);
                  uploadList.push(localFile);
                  sizeUpload += (_a = localFile.size) !== null && _a !== void 0 ? _a : 0;
                  localPosition += 1;
              }
              else if (fileNameCompare > 0) {
                  let icon = serverFile.type === "folder" ? `📁` : `🗑️`;
                  logger.standard(`${icon}  Delete: ${serverFile.name}    `);
                  deleteList.push(serverFile);
                  sizeDelete += (_b = serverFile.size) !== null && _b !== void 0 ? _b : 0;
                  serverPosition += 1;
              }
              else if (fileNameCompare === 0) {
                  // paths are a match
                  if (localFile.type === "file" && serverFile.type === "file") {
                      if (localFile.hash === serverFile.hash) {
                          logger.standard(`⚖️  File content is the same, doing nothing: ${localFile.name}`);
                      }
                      else {
                          logger.standard(`🔁 File replace: ${localFile.name}`);
                          sizeReplace += (_c = localFile.size) !== null && _c !== void 0 ? _c : 0;
                          replaceList.push(localFile);
                      }
                  }
                  localPosition += 1;
                  serverPosition += 1;
              }
          }
          return {
              upload: uploadList,
              delete: deleteList,
              replace: replaceList,
              sizeDelete,
              sizeReplace,
              sizeUpload
          };
      }
  }
  exports.HashDiff = HashDiff;
  
  
  /***/ }),
  
  /***/ 232:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  };
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.deploy = void 0;
  const ftp = __importStar(__nccwpck_require__(7957));
  const fs_1 = __importDefault(__nccwpck_require__(5747));
  const types_1 = __nccwpck_require__(6703);
  const HashDiff_1 = __nccwpck_require__(9946);
  const utilities_1 = __nccwpck_require__(4389);
  const pretty_bytes_1 = __importDefault(__nccwpck_require__(5168));
  const errorHandling_1 = __nccwpck_require__(3678);
  const syncProvider_1 = __nccwpck_require__(1904);
  const localFiles_1 = __nccwpck_require__(8660);
  function downloadFileList(client, logger, path) {
      return __awaiter(this, void 0, void 0, function* () {
          // note: originally this was using a writable stream instead of a buffer file
          // basic-ftp doesn't seam to close the connection when using steams over some ftps connections. This appears to be dependent on the ftp server
          const tempFileNameHack = ".ftp-deploy-sync-server-state-buffer-file---delete.json";
          yield utilities_1.retryRequest(logger, () => __awaiter(this, void 0, void 0, function* () { return yield client.downloadTo(tempFileNameHack, path); }));
          const fileAsString = fs_1.default.readFileSync(tempFileNameHack, { encoding: "utf-8" });
          const fileAsObject = JSON.parse(fileAsString);
          fs_1.default.unlinkSync(tempFileNameHack);
          return fileAsObject;
      });
  }
  function createLocalState(localFiles, logger, args) {
      logger.verbose(`Creating local state at ${args["local-dir"]}${args["state-name"]}`);
      fs_1.default.writeFileSync(`${args["local-dir"]}${args["state-name"]}`, JSON.stringify(localFiles, undefined, 4), { encoding: "utf8" });
      logger.verbose("Local state created");
  }
  function connect(client, args, logger) {
      return __awaiter(this, void 0, void 0, function* () {
          let secure = false;
          if (args.protocol === "ftps") {
              secure = true;
          }
          else if (args.protocol === "ftps-legacy") {
              secure = "implicit";
          }
          client.ftp.verbose = args["log-level"] === "verbose";
          const rejectUnauthorized = args.security === "strict";
          try {
              yield client.access({
                  host: args.server,
                  user: args.username,
                  password: args.password,
                  port: args.port,
                  secure: secure,
                  secureOptions: {
                      rejectUnauthorized: rejectUnauthorized
                  }
              });
          }
          catch (error) {
              logger.all("Failed to connect, are you sure your server works via FTP or FTPS? Users sometimes get this error when the server only supports SFTP.");
              throw error;
          }
          if (args["log-level"] === "verbose") {
              client.trackProgress(info => {
                  logger.verbose(`${info.type} progress for "${info.name}". Progress: ${info.bytes} bytes of ${info.bytesOverall} bytes`);
              });
          }
      });
  }
  function getServerFiles(client, logger, timings, args) {
      return __awaiter(this, void 0, void 0, function* () {
          try {
              yield syncProvider_1.ensureDir(client, logger, timings, args["server-dir"]);
              if (args["dangerous-clean-slate"]) {
                  logger.all(`----------------------------------------------------------------`);
                  logger.all("🗑️ Removing all files on the server because 'dangerous-clean-slate' was set, this will make the deployment very slow...");
                  yield client.clearWorkingDir();
                  logger.all("Clear complete");
                  throw new Error("nope");
              }
              const serverFiles = yield downloadFileList(client, logger, args["state-name"]);
              logger.all(`----------------------------------------------------------------`);
              logger.all(`Last published on 📅 ${new Date(serverFiles.generatedTime).toLocaleDateString(undefined, { weekday: "long", year: "numeric", month: "long", day: "numeric", hour: "numeric", minute: "numeric" })}`);
              return serverFiles;
          }
          catch (error) {
              logger.all(`----------------------------------------------------------------`);
              logger.all(`No file exists on the server "${args["server-dir"] + args["state-name"]}" - this must be your first publish! 🎉`);
              logger.all(`The first publish will take a while... but once the initial sync is done only differences are published!`);
              logger.all(`If you get this message and its NOT your first publish, something is wrong.`);
              // set the server state to nothing, because we don't know what the server state is
              return {
                  description: types_1.syncFileDescription,
                  version: types_1.currentSyncFileVersion,
                  generatedTime: new Date().getTime(),
                  data: [],
              };
          }
      });
  }
  function deploy(args, logger, timings) {
      return __awaiter(this, void 0, void 0, function* () {
          timings.start("total");
          // header
          logger.all(`----------------------------------------------------------------`);
          logger.all(`🚀 Thanks for using ftp-deploy. Let's deploy some stuff!   `);
          logger.all(`----------------------------------------------------------------`);
          logger.all(`If you found this project helpful, please support it`);
          logger.all(`by giving it a ⭐ on Github --> https://github.com/devrma/FTP-Deploy-Action`);
          logger.all(`or add a badge 🏷️ to your projects readme --> https://github.com/devrma/FTP-Deploy-Action#badge`);
          logger.verbose(`Using the following excludes filters: ${JSON.stringify(args.exclude)}`);
          timings.start("hash");
          const localFiles = yield localFiles_1.getLocalFiles(args);
          timings.stop("hash");
          createLocalState(localFiles, logger, args);
          const client = new ftp.Client();
          global.reconnect = function () {
              return __awaiter(this, void 0, void 0, function* () {
                  timings.start("connecting");
                  yield connect(client, args, logger);
                  timings.stop("connecting");
              });
          };
          let totalBytesUploaded = 0;
          try {
              yield global.reconnect();
              const serverFiles = yield getServerFiles(client, logger, timings, args);
              timings.start("logging");
              const diffTool = new HashDiff_1.HashDiff();
              const diffs = diffTool.getDiffs(localFiles, serverFiles, logger);
              timings.stop("logging");
              totalBytesUploaded = diffs.sizeUpload + diffs.sizeReplace;
              timings.start("upload");
              try {
                  const syncProvider = new syncProvider_1.FTPSyncProvider(client, logger, timings, args["local-dir"], args["server-dir"], args["state-name"], args["dry-run"]);
                  yield syncProvider.syncLocalToServer(diffs);
              }
              finally {
                  timings.stop("upload");
              }
          }
          catch (error) {
              errorHandling_1.prettyError(logger, args, error);
              throw error;
          }
          finally {
              client.close();
              timings.stop("total");
          }
          const uploadSpeed = pretty_bytes_1.default(totalBytesUploaded / (timings.getTime("upload") / 1000));
          // footer
          logger.all(`----------------------------------------------------------------`);
          logger.all(`Time spent hashing: ${timings.getTimeFormatted("hash")}`);
          logger.all(`Time spent connecting to server: ${timings.getTimeFormatted("connecting")}`);
          logger.all(`Time spent deploying: ${timings.getTimeFormatted("upload")}(${uploadSpeed} / second)`);
          logger.all(`  - changing dirs: ${timings.getTimeFormatted("changingDir")}`);
          logger.all(`  - logging: ${timings.getTimeFormatted("logging")}`);
          logger.all(`----------------------------------------------------------------`);
          logger.all(`Total time: ${timings.getTimeFormatted("total")}`);
          logger.all(`----------------------------------------------------------------`);
      });
  }
  exports.deploy = deploy;
  
  
  /***/ }),
  
  /***/ 3678:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.prettyError = void 0;
  const types_1 = __nccwpck_require__(6703);
  function logOriginalError(logger, error) {
      logger.all();
      logger.all(`----------------------------------------------------------------`);
      logger.all(`----------------------  full error below  ----------------------`);
      logger.all(`----------------------------------------------------------------`);
      logger.all();
      logger.all(error);
  }
  /**
   * Converts a exception to helpful debug info
   * @param error exception
   */
  function prettyError(logger, args, error) {
      logger.all();
      logger.all(`----------------------------------------------------------------`);
      logger.all(`--------------  🔥🔥🔥 an error occurred  🔥🔥🔥  --------------`);
      logger.all(`----------------------------------------------------------------`);
      const ftpError = error;
      if (typeof error.code === "string") {
          const errorCode = error.code;
          if (errorCode === "ENOTFOUND") {
              logger.all(`The server "${args.server}" doesn't seem to exist. Do you have a typo?`);
          }
      }
      else if (typeof error.name === "string") {
          const errorName = error.name;
          if (errorName.includes("ERR_TLS_CERT_ALTNAME_INVALID")) {
              logger.all(`The certificate for "${args.server}" is likely shared. The host did not place your server on the list of valid domains for this cert.`);
              logger.all(`This is a common issue with shared hosts. You have a few options:`);
              logger.all(` - Ignore this error by setting security back to loose`);
              logger.all(` - Contact your hosting provider and ask them for your servers hostname`);
          }
      }
      else if (typeof ftpError.code === "number") {
          if (ftpError.code === types_1.ErrorCode.NotLoggedIn) {
              const serverRequiresFTPS = ftpError.message.toLowerCase().includes("must use encryption");
              if (serverRequiresFTPS) {
                  logger.all(`The server you are connecting to requires encryption (ftps)`);
                  logger.all(`Enable FTPS by using the protocol option.`);
              }
              else {
                  logger.all(`Could not login with the username "${args.username}" and password "${args.password}".`);
                  logger.all(`Make sure you can login with those credentials. If you have a space or a quote in your username or password be sure to escape them!`);
              }
          }
      }
      logOriginalError(logger, error);
  }
  exports.prettyError = prettyError;
  
  
  /***/ }),
  
  /***/ 8660:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  };
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.getLocalFiles = exports.applyExcludeFilter = void 0;
  const readdir_enhanced_1 = __importDefault(__nccwpck_require__(8811));
  const types_1 = __nccwpck_require__(6703);
  const HashDiff_1 = __nccwpck_require__(9946);
  const multiMatch_1 = __importDefault(__nccwpck_require__(4865));
  function applyExcludeFilter(stat, excludeFilter) {
      // match exclude, return immediatley
      if (excludeFilter.length > 0) {
          const pathWithFolderSlash = stat.path + (stat.isDirectory() ? "/" : "");
          const excludeMatch = multiMatch_1.default(pathWithFolderSlash, excludeFilter, { matchBase: true, dot: true });
          if (excludeMatch.length > 0) {
              return false;
          }
      }
      return true;
  }
  exports.applyExcludeFilter = applyExcludeFilter;
  function getLocalFiles(args) {
      return __awaiter(this, void 0, void 0, function* () {
          const files = yield readdir_enhanced_1.default.async(args["local-dir"], { deep: true, stats: true, sep: "/", filter: (stat) => applyExcludeFilter(stat, args.exclude) });
          const records = [];
          for (let stat of files) {
              if (stat.isDirectory()) {
                  records.push({
                      type: "folder",
                      name: stat.path,
                      size: undefined
                  });
                  continue;
              }
              if (stat.isFile()) {
                  records.push({
                      type: "file",
                      name: stat.path,
                      size: stat.size,
                      hash: yield HashDiff_1.fileHash(args["local-dir"] + stat.path, "sha256")
                  });
                  continue;
              }
              if (stat.isSymbolicLink()) {
                  console.warn("This script is currently unable to handle symbolic links - please add a feature request if you need this");
              }
          }
          return {
              description: types_1.syncFileDescription,
              version: types_1.currentSyncFileVersion,
              generatedTime: new Date().getTime(),
              data: records
          };
      });
  }
  exports.getLocalFiles = getLocalFiles;
  
  
  /***/ }),
  
  /***/ 8347:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.deploy = exports.excludeDefaults = void 0;
  const deploy_1 = __nccwpck_require__(232);
  const utilities_1 = __nccwpck_require__(4389);
  /**
   * Default excludes, ignores all git files and the node_modules folder
   * **\/.git* ignores all FILES that start with .git(in any folder or sub-folder)
   * **\/.git*\/** ignores all FOLDERS that start with .git (in any folder or sub-folder)
   * **\/node_modules\/** ignores all FOLDERS named node_modules (in any folder or sub-folder)
   */
  exports.excludeDefaults = ["**/.git*", "**/.git*/**", "**/node_modules/**"];
  /**
   * Syncs a local folder with a remote folder over FTP.
   * After the initial sync only differences are synced, making deployments super fast!
   */
  function deploy(args) {
      return __awaiter(this, void 0, void 0, function* () {
          const argsWithDefaults = utilities_1.getDefaultSettings(args);
          const logger = new utilities_1.Logger(argsWithDefaults["log-level"]);
          const timings = new utilities_1.Timings();
          yield deploy_1.deploy(argsWithDefaults, logger, timings);
      });
  }
  exports.deploy = deploy;
  
  
  /***/ }),
  
  /***/ 1904:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  };
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.FTPSyncProvider = exports.ensureDir = void 0;
  const pretty_bytes_1 = __importDefault(__nccwpck_require__(5168));
  const types_1 = __nccwpck_require__(6703);
  const utilities_1 = __nccwpck_require__(4389);
  function ensureDir(client, logger, timings, folder) {
      return __awaiter(this, void 0, void 0, function* () {
          timings.start("changingDir");
          logger.verbose(`  changing dir to ${folder}`);
          yield utilities_1.retryRequest(logger, () => __awaiter(this, void 0, void 0, function* () { return yield client.ensureDir(folder); }));
          logger.verbose(`  dir changed`);
          timings.stop("changingDir");
      });
  }
  exports.ensureDir = ensureDir;
  class FTPSyncProvider {
      constructor(client, logger, timings, localPath, serverPath, stateName, dryRun) {
          this.client = client;
          this.logger = logger;
          this.timings = timings;
          this.localPath = localPath;
          this.serverPath = serverPath;
          this.stateName = stateName;
          this.dryRun = dryRun;
      }
      /**
       * Converts a file path (ex: "folder/otherfolder/file.txt") to an array of folder and a file path
       * @param fullPath
       */
      getFileBreadcrumbs(fullPath) {
          var _a;
          // todo see if this regex will work for nonstandard folder names
          // todo what happens if the path is relative to the root dir? (starts with /)
          const pathSplit = fullPath.split("/");
          const file = (_a = pathSplit === null || pathSplit === void 0 ? void 0 : pathSplit.pop()) !== null && _a !== void 0 ? _a : ""; // get last item
          const folders = pathSplit.filter(folderName => folderName != "");
          return {
              folders: folders.length === 0 ? null : folders,
              file: file === "" ? null : file
          };
      }
      /**
       * Navigates up {dirCount} number of directories from the current working dir
       */
      upDir(dirCount) {
          return __awaiter(this, void 0, void 0, function* () {
              if (typeof dirCount !== "number") {
                  return;
              }
              // navigate back to the starting folder
              for (let i = 0; i < dirCount; i++) {
                  yield utilities_1.retryRequest(this.logger, () => __awaiter(this, void 0, void 0, function* () { return yield this.client.cdup(); }));
              }
          });
      }
      createFolder(folderPath) {
          var _a;
          return __awaiter(this, void 0, void 0, function* () {
              this.logger.all(`creating folder "${folderPath + "/"}"`);
              if (this.dryRun === true) {
                  return;
              }
              const path = this.getFileBreadcrumbs(folderPath + "/");
              if (path.folders === null) {
                  this.logger.verbose(`  no need to change dir`);
              }
              else {
                  yield ensureDir(this.client, this.logger, this.timings, path.folders.join("/"));
              }
              // navigate back to the root folder
              yield this.upDir((_a = path.folders) === null || _a === void 0 ? void 0 : _a.length);
              this.logger.verbose(`  completed`);
          });
      }
      removeFile(filePath) {
          return __awaiter(this, void 0, void 0, function* () {
              this.logger.all(`removing "${filePath}"`);
              if (this.dryRun === false) {
                  try {
                      yield utilities_1.retryRequest(this.logger, () => __awaiter(this, void 0, void 0, function* () { return yield this.client.remove(filePath); }));
                  }
                  catch (e) {
                      // this error is common when a file was deleted on the server directly
                      if (e.code === types_1.ErrorCode.FileNotFoundOrNoAccess) {
                          this.logger.standard("File not found or you don't have access to the file - skipping...");
                      }
                      else {
                          throw e;
                      }
                  }
              }
              this.logger.verbose(`  file removed`);
              this.logger.verbose(`  completed`);
          });
      }
      removeFolder(folderPath) {
          var _a;
          return __awaiter(this, void 0, void 0, function* () {
              this.logger.all(`removing folder "${folderPath + "/"}"`);
              const path = this.getFileBreadcrumbs(folderPath + "/");
              if (path.folders === null) {
                  this.logger.verbose(`  no need to change dir`);
              }
              else {
                  this.logger.verbose(`  removing folder "${path.folders.join("/") + "/"}"`);
                  if (this.dryRun === false) {
                      try {
                          yield utilities_1.retryRequest(this.logger, () => __awaiter(this, void 0, void 0, function* () { return yield this.client.removeDir(path.folders.join("/") + "/"); }));
                      }
                      catch (e) {
                          if (e.code == 550){
                              this.logger.all("Error when trying to delete folder - skipping...");
                          }
                          else {
                              throw e;
                          }
                      }
                  }
              }
              // navigate back to the root folder
              yield this.upDir((_a = path.folders) === null || _a === void 0 ? void 0 : _a.length);
              this.logger.verbose(`  completed`);
          });
      }
      uploadFile(filePath, type = "upload") {
          return __awaiter(this, void 0, void 0, function* () {
              const typePresent = type === "upload" ? "uploading" : "replacing";
              const typePast = type === "upload" ? "uploaded" : "replaced";
              this.logger.all(`${typePresent} "${filePath}"`);
              if (this.dryRun === false) {
                  yield utilities_1.retryRequest(this.logger, () => __awaiter(this, void 0, void 0, function* () { return yield this.client.uploadFrom(this.localPath + filePath, filePath); }));
              }
              this.logger.verbose(`  file ${typePast}`);
          });
      }
      syncLocalToServer(diffs) {
          return __awaiter(this, void 0, void 0, function* () {
              const totalCount = diffs.delete.length + diffs.upload.length + diffs.replace.length;
              this.logger.all(`----------------------------------------------------------------`);
              this.logger.all(`Making changes to ${totalCount} ${utilities_1.pluralize(totalCount, "file/folder", "files/folders")} to sync server state`);
              this.logger.all(`Uploading: ${pretty_bytes_1.default(diffs.sizeUpload)} -- Deleting: ${pretty_bytes_1.default(diffs.sizeDelete)} -- Replacing: ${pretty_bytes_1.default(diffs.sizeReplace)}`);
              this.logger.all(`----------------------------------------------------------------`);
              // create new folders
              for (const file of diffs.upload.filter(item => item.type === "folder")) {
                  yield this.createFolder(file.name);
              }
              // upload new files
              for (const file of diffs.upload.filter(item => item.type === "file").filter(item => item.name !== this.stateName)) {
                  yield this.uploadFile(file.name, "upload");
              }
              // replace new files
              for (const file of diffs.replace.filter(item => item.type === "file").filter(item => item.name !== this.stateName)) {
                  // note: FTP will replace old files with new files. We run replacements after uploads to limit downtime
                  yield this.uploadFile(file.name, "replace");
              }
              // delete old files
              for (const file of diffs.delete.filter(item => item.type === "file")) {
                  yield this.removeFile(file.name);
              }
              // delete old folders
              for (const file of diffs.delete.filter(item => item.type === "folder")) {
                  yield this.removeFolder(file.name);
              }
              this.logger.all(`----------------------------------------------------------------`);
              this.logger.all(`🎉 Sync complete. Saving current server state to "${this.serverPath + this.stateName}"`);
              if (this.dryRun === false) {
                  yield utilities_1.retryRequest(this.logger, () => __awaiter(this, void 0, void 0, function* () { return yield this.client.uploadFrom(this.localPath + this.stateName, this.stateName); }));
              }
          });
      }
  }
  exports.FTPSyncProvider = FTPSyncProvider;
  
  
  /***/ }),
  
  /***/ 6703:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.ErrorCode = exports.syncFileDescription = exports.currentSyncFileVersion = void 0;
  exports.currentSyncFileVersion = "1.0.0";
  exports.syncFileDescription = "DO NOT DELETE THIS FILE. This file is used to keep track of which files have been synced in the most recent deployment. If you delete this file a resync will need to be done (which can take a while) - read more: https://github.com/devrma/FTP-Deploy-Action";
  var ErrorCode;
  (function (ErrorCode) {
      // The requested action is being initiated, expect another reply before proceeding with a new command.
      ErrorCode[ErrorCode["RestartMarkerReplay"] = 110] = "RestartMarkerReplay";
      ErrorCode[ErrorCode["ServiceReadyInNNNMinutes"] = 120] = "ServiceReadyInNNNMinutes";
      ErrorCode[ErrorCode["DataConnectionAlreadyOpenStartingTransfer"] = 125] = "DataConnectionAlreadyOpenStartingTransfer";
      ErrorCode[ErrorCode["FileStatusOkayOpeningDataConnection"] = 150] = "FileStatusOkayOpeningDataConnection";
      // The requested action has been successfully completed.
      ErrorCode[ErrorCode["CommandNotImplemented"] = 202] = "CommandNotImplemented";
      ErrorCode[ErrorCode["SystemStatus"] = 211] = "SystemStatus";
      ErrorCode[ErrorCode["DirectoryStatus"] = 212] = "DirectoryStatus";
      ErrorCode[ErrorCode["FileStatus"] = 213] = "FileStatus";
      ErrorCode[ErrorCode["HelpMessage"] = 214] = "HelpMessage";
      ErrorCode[ErrorCode["IANAOfficialName"] = 215] = "IANAOfficialName";
      ErrorCode[ErrorCode["ReadyForNewUser"] = 220] = "ReadyForNewUser";
      ErrorCode[ErrorCode["ClosingControlConnection"] = 221] = "ClosingControlConnection";
      ErrorCode[ErrorCode["DataConnectionOpen"] = 225] = "DataConnectionOpen";
      ErrorCode[ErrorCode["SuccessNowClosingDataConnection"] = 226] = "SuccessNowClosingDataConnection";
      ErrorCode[ErrorCode["EnteringPassiveMode"] = 227] = "EnteringPassiveMode";
      ErrorCode[ErrorCode["EnteringLongPassiveMode"] = 228] = "EnteringLongPassiveMode";
      ErrorCode[ErrorCode["EnteringExtendedPassiveMode"] = 229] = "EnteringExtendedPassiveMode";
      ErrorCode[ErrorCode["UserLoggedIn"] = 230] = "UserLoggedIn";
      ErrorCode[ErrorCode["UserLoggedOut"] = 231] = "UserLoggedOut";
      ErrorCode[ErrorCode["LogoutWillCompleteWhenTransferDone"] = 232] = "LogoutWillCompleteWhenTransferDone";
      ErrorCode[ErrorCode["ServerAcceptsAuthenticationMethod"] = 234] = "ServerAcceptsAuthenticationMethod";
      ErrorCode[ErrorCode["ActionComplete"] = 250] = "ActionComplete";
      ErrorCode[ErrorCode["PathNameCreated"] = 257] = "PathNameCreated";
      // The command has been accepted, but the requested action is on hold, pending receipt of further information.
      ErrorCode[ErrorCode["UsernameOkayPasswordNeeded"] = 331] = "UsernameOkayPasswordNeeded";
      ErrorCode[ErrorCode["NeedAccountForLogin"] = 332] = "NeedAccountForLogin";
      ErrorCode[ErrorCode["RequestedFileActionPendingFurtherInformation"] = 350] = "RequestedFileActionPendingFurtherInformation";
      // The command was not accepted and the requested action did not take place, but the error condition is temporary and the action may be requested again.
      ErrorCode[ErrorCode["ServiceNotAvailable"] = 421] = "ServiceNotAvailable";
      ErrorCode[ErrorCode["CantOpenDataConnection"] = 425] = "CantOpenDataConnection";
      ErrorCode[ErrorCode["ConnectionClosed"] = 426] = "ConnectionClosed";
      ErrorCode[ErrorCode["InvalidUsernameOrPassword"] = 430] = "InvalidUsernameOrPassword";
      ErrorCode[ErrorCode["HostUnavailable"] = 434] = "HostUnavailable";
      ErrorCode[ErrorCode["FileActionNotTaken"] = 450] = "FileActionNotTaken";
      ErrorCode[ErrorCode["LocalErrorProcessing"] = 451] = "LocalErrorProcessing";
      ErrorCode[ErrorCode["InsufficientStorageSpaceOrFileInUse"] = 452] = "InsufficientStorageSpaceOrFileInUse";
      // Syntax error, command unrecognized and the requested action did not take place. This may include errors such as command line too long.
      ErrorCode[ErrorCode["SyntaxErrorInParameters"] = 501] = "SyntaxErrorInParameters";
      ErrorCode[ErrorCode["CommandNotImpemented"] = 502] = "CommandNotImpemented";
      ErrorCode[ErrorCode["BadSequenceOfCommands"] = 503] = "BadSequenceOfCommands";
      ErrorCode[ErrorCode["CommandNotImplementedForThatParameter"] = 504] = "CommandNotImplementedForThatParameter";
      ErrorCode[ErrorCode["NotLoggedIn"] = 530] = "NotLoggedIn";
      ErrorCode[ErrorCode["NeedAccountForStoringFiles"] = 532] = "NeedAccountForStoringFiles";
      ErrorCode[ErrorCode["CouldNotConnectToServerRequiresSSL"] = 534] = "CouldNotConnectToServerRequiresSSL";
      ErrorCode[ErrorCode["FileNotFoundOrNoAccess"] = 550] = "FileNotFoundOrNoAccess";
      ErrorCode[ErrorCode["UnknownPageType"] = 551] = "UnknownPageType";
      ErrorCode[ErrorCode["ExceededStorageAllocation"] = 552] = "ExceededStorageAllocation";
      ErrorCode[ErrorCode["FileNameNotAllowed"] = 553] = "FileNameNotAllowed";
      // Replies regarding confidentiality and integrity
      ErrorCode[ErrorCode["IntegrityProtectedReply"] = 631] = "IntegrityProtectedReply";
      ErrorCode[ErrorCode["ConfidentialityAndIntegrityProtectedReply"] = 632] = "ConfidentialityAndIntegrityProtectedReply";
      ErrorCode[ErrorCode["ConfidentialityProtectedReply"] = 633] = "ConfidentialityProtectedReply";
      // Common Winsock Error Codes[2] (These are not FTP return codes)
      ErrorCode[ErrorCode["ConnectionClosedByServer"] = 10054] = "ConnectionClosedByServer";
      ErrorCode[ErrorCode["CannotConnect"] = 10060] = "CannotConnect";
      ErrorCode[ErrorCode["CannotConnectRefusedByServer"] = 10061] = "CannotConnectRefusedByServer";
      ErrorCode[ErrorCode["DirectoryNotEmpty"] = 10066] = "DirectoryNotEmpty";
      ErrorCode[ErrorCode["TooManyUsers"] = 10068] = "TooManyUsers";
  })(ErrorCode = exports.ErrorCode || (exports.ErrorCode = {}));
  ;
  
  
  /***/ }),
  
  /***/ 4389:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
      return new (P || (P = Promise))(function (resolve, reject) {
          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
          step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
  };
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.getDefaultSettings = exports.Timer = exports.Timings = exports.retryRequest = exports.pluralize = exports.Logger = void 0;
  const pretty_ms_1 = __importDefault(__nccwpck_require__(1127));
  const module_1 = __nccwpck_require__(8347);
  const types_1 = __nccwpck_require__(6703);
  class Logger {
      constructor(level) {
          this.level = level;
      }
      all(...data) {
          console.log(...data);
      }
      standard(...data) {
          if (this.level === "minimal") {
              return;
          }
          console.log(...data);
      }
      verbose(...data) {
          if (this.level !== "verbose") {
              return;
          }
          console.log(...data);
      }
  }
  exports.Logger = Logger;
  function pluralize(count, singular, plural) {
      if (count === 1) {
          return singular;
      }
      return plural;
  }
  exports.pluralize = pluralize;
  /**
   * retry a request
   *
   * @example retryRequest(logger, async () => await item());
   */
  function retryRequest(logger, callback) {
      return __awaiter(this, void 0, void 0, function* () {
          try {
              return yield callback();
          }
          catch (e) {
              if (e.code >= 400 && e.code <= 499) {
                  logger.standard("400 level error from server when performing action - retrying...");
                  logger.standard(e);
                  if (e.code === types_1.ErrorCode.ConnectionClosed) {
                      logger.all("Connection closed. This library does not currently handle reconnects");
                      // await global.reconnect();
                      // todo reset current working dir
                      throw e;
                  }
                  return yield callback();
              }
              else {
                  throw e;
              }
          }
      });
  }
  exports.retryRequest = retryRequest;
  class Timings {
      constructor() {
          this.timers = {};
      }
      start(type) {
          if (this.timers[type] === undefined) {
              this.timers[type] = new Timer();
          }
          this.timers[type].start();
      }
      stop(type) {
          this.timers[type].stop();
      }
      getTime(type) {
          const timer = this.timers[type];
          if (timer === undefined || timer.time === null) {
              return 0;
          }
          return timer.time;
      }
      getTimeFormatted(type) {
          const timer = this.timers[type];
          if (timer === undefined || timer.time === null) {
              return "💣 Failed";
          }
          return pretty_ms_1.default(timer.time, { verbose: true });
      }
  }
  exports.Timings = Timings;
  class Timer {
      constructor() {
          this.totalTime = null;
          this.startTime = null;
          this.endTime = null;
      }
      start() {
          this.startTime = process.hrtime();
      }
      stop() {
          if (this.startTime === null) {
              throw new Error("Called .stop() before calling .start()");
          }
          this.endTime = process.hrtime(this.startTime);
          const currentSeconds = this.totalTime === null ? 0 : this.totalTime[0];
          const currentNS = this.totalTime === null ? 0 : this.totalTime[1];
          this.totalTime = [
              currentSeconds + this.endTime[0],
              currentNS + this.endTime[1]
          ];
      }
      get time() {
          if (this.totalTime === null) {
              return null;
          }
          return (this.totalTime[0] * 1000) + (this.totalTime[1] / 1000000);
      }
  }
  exports.Timer = Timer;
  function getDefaultSettings(withoutDefaults) {
      var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
      if (withoutDefaults["local-dir"] !== undefined) {
          if (!withoutDefaults["local-dir"].endsWith("/")) {
              throw new Error("local-dir should be a folder (must end with /)");
          }
      }
      if (withoutDefaults["server-dir"] !== undefined) {
          if (!withoutDefaults["server-dir"].endsWith("/")) {
              throw new Error("server-dir should be a folder (must end with /)");
          }
      }
      return {
          "server": withoutDefaults.server,
          "username": withoutDefaults.username,
          "password": withoutDefaults.password,
          "port": (_a = withoutDefaults.port) !== null && _a !== void 0 ? _a : 21,
          "protocol": (_b = withoutDefaults.protocol) !== null && _b !== void 0 ? _b : "ftp",
          "local-dir": (_c = withoutDefaults["local-dir"]) !== null && _c !== void 0 ? _c : "./",
          "server-dir": (_d = withoutDefaults["server-dir"]) !== null && _d !== void 0 ? _d : "./",
          "state-name": (_e = withoutDefaults["state-name"]) !== null && _e !== void 0 ? _e : ".ftp-deploy-sync-state.json",
          "dry-run": (_f = withoutDefaults["dry-run"]) !== null && _f !== void 0 ? _f : false,
          "dangerous-clean-slate": (_g = withoutDefaults["dangerous-clean-slate"]) !== null && _g !== void 0 ? _g : false,
          "exclude": (_h = withoutDefaults.exclude) !== null && _h !== void 0 ? _h : module_1.excludeDefaults,
          "log-level": (_j = withoutDefaults["log-level"]) !== null && _j !== void 0 ? _j : "standard",
          "security": (_k = withoutDefaults.security) !== null && _k !== void 0 ? _k : "loose",
      };
  }
  exports.getDefaultSettings = getDefaultSettings;
  
  
  /***/ }),
  
  /***/ 6554:
  /***/ ((module) => {
  
  "use strict";
  
  
  const arrayDiffer = (array, ...values) => {
  	const rest = new Set([].concat(...values));
  	return array.filter(element => !rest.has(element));
  };
  
  module.exports = arrayDiffer;
  
  
  /***/ }),
  
  /***/ 9600:
  /***/ ((module) => {
  
  "use strict";
  
  
  module.exports = (...arguments_) => {
  	return [...new Set([].concat(...arguments_))];
  };
  
  
  /***/ }),
  
  /***/ 1546:
  /***/ ((module) => {
  
  "use strict";
  
  
  const arrify = value => {
  	if (value === null || value === undefined) {
  		return [];
  	}
  
  	if (Array.isArray(value)) {
  		return value;
  	}
  
  	if (typeof value === 'string') {
  		return [value];
  	}
  
  	if (typeof value[Symbol.iterator] === 'function') {
  		return [...value];
  	}
  
  	return [value];
  };
  
  module.exports = arrify;
  
  
  /***/ }),
  
  /***/ 9417:
  /***/ ((module) => {
  
  "use strict";
  
  module.exports = balanced;
  function balanced(a, b, str) {
    if (a instanceof RegExp) a = maybeMatch(a, str);
    if (b instanceof RegExp) b = maybeMatch(b, str);
  
    var r = range(a, b, str);
  
    return r && {
      start: r[0],
      end: r[1],
      pre: str.slice(0, r[0]),
      body: str.slice(r[0] + a.length, r[1]),
      post: str.slice(r[1] + b.length)
    };
  }
  
  function maybeMatch(reg, str) {
    var m = str.match(reg);
    return m ? m[0] : null;
  }
  
  balanced.range = range;
  function range(a, b, str) {
    var begs, beg, left, right, result;
    var ai = str.indexOf(a);
    var bi = str.indexOf(b, ai + 1);
    var i = ai;
  
    if (ai >= 0 && bi > 0) {
      if(a===b) {
        return [ai, bi];
      }
      begs = [];
      left = str.length;
  
      while (i >= 0 && !result) {
        if (i == ai) {
          begs.push(i);
          ai = str.indexOf(a, i + 1);
        } else if (begs.length == 1) {
          result = [ begs.pop(), bi ];
        } else {
          beg = begs.pop();
          if (beg < left) {
            left = beg;
            right = bi;
          }
  
          bi = str.indexOf(b, i + 1);
        }
  
        i = ai < bi && ai >= 0 ? ai : bi;
      }
  
      if (begs.length) {
        result = [ left, right ];
      }
    }
  
    return result;
  }
  
  
  /***/ }),
  
  /***/ 8337:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.Client = void 0;
  const fs_1 = __nccwpck_require__(5747);
  const path_1 = __nccwpck_require__(5622);
  const tls_1 = __nccwpck_require__(4016);
  const util_1 = __nccwpck_require__(1669);
  const FtpContext_1 = __nccwpck_require__(9052);
  const parseList_1 = __nccwpck_require__(2993);
  const ProgressTracker_1 = __nccwpck_require__(7170);
  const StringWriter_1 = __nccwpck_require__(8184);
  const parseListMLSD_1 = __nccwpck_require__(8157);
  const netUtils_1 = __nccwpck_require__(6288);
  const transfer_1 = __nccwpck_require__(5803);
  const parseControlResponse_1 = __nccwpck_require__(9948);
  // Use promisify to keep the library compatible with Node 8.
  const fsReadDir = util_1.promisify(fs_1.readdir);
  const fsMkDir = util_1.promisify(fs_1.mkdir);
  const fsStat = util_1.promisify(fs_1.stat);
  const fsOpen = util_1.promisify(fs_1.open);
  const fsClose = util_1.promisify(fs_1.close);
  const fsUnlink = util_1.promisify(fs_1.unlink);
  const LIST_COMMANDS_DEFAULT = ["LIST -a", "LIST"];
  const LIST_COMMANDS_MLSD = ["MLSD", "LIST -a", "LIST"];
  /**
   * High-level API to interact with an FTP server.
   */
  class Client {
      /**
       * Instantiate an FTP client.
       *
       * @param timeout  Timeout in milliseconds, use 0 for no timeout. Optional, default is 30 seconds.
       */
      constructor(timeout = 30000) {
          this.availableListCommands = LIST_COMMANDS_DEFAULT;
          this.ftp = new FtpContext_1.FTPContext(timeout);
          this.prepareTransfer = this._enterFirstCompatibleMode([transfer_1.enterPassiveModeIPv6, transfer_1.enterPassiveModeIPv4]);
          this.parseList = parseList_1.parseList;
          this._progressTracker = new ProgressTracker_1.ProgressTracker();
      }
      /**
       * Close the client and all open socket connections.
       *
       * Close the client and all open socket connections. The client can’t be used anymore after calling this method,
       * you have to either reconnect with `access` or `connect` or instantiate a new instance to continue any work.
       * A client is also closed automatically if any timeout or connection error occurs.
       */
      close() {
          this.ftp.close();
          this._progressTracker.stop();
      }
      /**
       * Returns true if the client is closed and can't be used anymore.
       */
      get closed() {
          return this.ftp.closed;
      }
      /**
       * Connect (or reconnect) to an FTP server.
       *
       * This is an instance method and thus can be called multiple times during the lifecycle of a `Client`
       * instance. Whenever you do, the client is reset with a new control connection. This also implies that
       * you can reopen a `Client` instance that has been closed due to an error when reconnecting with this
       * method. In fact, reconnecting is the only way to continue using a closed `Client`.
       *
       * @param host  Host the client should connect to. Optional, default is "localhost".
       * @param port  Port the client should connect to. Optional, default is 21.
       */
      connect(host = "localhost", port = 21) {
          this.ftp.reset();
          this.ftp.socket.connect({
              host,
              port,
              family: this.ftp.ipFamily
          }, () => this.ftp.log(`Connected to ${netUtils_1.describeAddress(this.ftp.socket)} (${netUtils_1.describeTLS(this.ftp.socket)})`));
          return this._handleConnectResponse();
      }
      /**
       * As `connect` but using implicit TLS. Implicit TLS is not an FTP standard and has been replaced by
       * explicit TLS. There are still FTP servers that support only implicit TLS, though.
       */
      connectImplicitTLS(host = "localhost", port = 21, tlsOptions = {}) {
          this.ftp.reset();
          this.ftp.socket = tls_1.connect(port, host, tlsOptions, () => this.ftp.log(`Connected to ${netUtils_1.describeAddress(this.ftp.socket)} (${netUtils_1.describeTLS(this.ftp.socket)})`));
          this.ftp.tlsOptions = tlsOptions;
          return this._handleConnectResponse();
      }
      /**
       * Handles the first reponse by an FTP server after the socket connection has been established.
       */
      _handleConnectResponse() {
          return this.ftp.handle(undefined, (res, task) => {
              if (res instanceof Error) {
                  // The connection has been destroyed by the FTPContext at this point.
                  task.reject(res);
              }
              else if (parseControlResponse_1.positiveCompletion(res.code)) {
                  task.resolve(res);
              }
              // Reject all other codes, including 120 "Service ready in nnn minutes".
              else {
                  // Don't stay connected but don't replace the socket yet by using reset()
                  // so the user can inspect properties of this instance.
                  this.ftp.socket.destroy();
                  task.reject(new FtpContext_1.FTPError(res));
              }
          });
      }
      /**
       * Send an FTP command and handle the first response.
       */
      send(command, ignoreErrorCodesDEPRECATED = false) {
          if (ignoreErrorCodesDEPRECATED) { // Deprecated starting from 3.9.0
              this.ftp.log("Deprecated call using send(command, flag) with boolean flag to ignore errors. Use sendIgnoringError(command).");
              return this.sendIgnoringError(command);
          }
          return this.ftp.request(command);
      }
      /**
       * Send an FTP command and ignore an FTP error response. Any other kind of error or timeout will still reject the Promise.
       *
       * @param command
       */
      sendIgnoringError(command) {
          return this.ftp.handle(command, (res, task) => {
              if (res instanceof FtpContext_1.FTPError) {
                  task.resolve({ code: res.code, message: res.message });
              }
              else if (res instanceof Error) {
                  task.reject(res);
              }
              else {
                  task.resolve(res);
              }
          });
      }
      /**
       * Upgrade the current socket connection to TLS.
       *
       * @param options  TLS options as in `tls.connect(options)`, optional.
       * @param command  Set the authentication command. Optional, default is "AUTH TLS".
       */
      async useTLS(options = {}, command = "AUTH TLS") {
          const ret = await this.send(command);
          this.ftp.socket = await netUtils_1.upgradeSocket(this.ftp.socket, options);
          this.ftp.tlsOptions = options; // Keep the TLS options for later data connections that should use the same options.
          this.ftp.log(`Control socket is using: ${netUtils_1.describeTLS(this.ftp.socket)}`);
          return ret;
      }
      /**
       * Login a user with a password.
       *
       * @param user  Username to use for login. Optional, default is "anonymous".
       * @param password  Password to use for login. Optional, default is "guest".
       */
      login(user = "anonymous", password = "guest") {
          this.ftp.log(`Login security: ${netUtils_1.describeTLS(this.ftp.socket)}`);
          return this.ftp.handle("USER " + user, (res, task) => {
              if (res instanceof Error) {
                  task.reject(res);
              }
              else if (parseControlResponse_1.positiveCompletion(res.code)) { // User logged in proceed OR Command superfluous
                  task.resolve(res);
              }
              else if (res.code === 331) { // User name okay, need password
                  this.ftp.send("PASS " + password);
              }
              else { // Also report error on 332 (Need account)
                  task.reject(new FtpContext_1.FTPError(res));
              }
          });
      }
      /**
       * Set the usual default settings.
       *
       * Settings used:
       * * Binary mode (TYPE I)
       * * File structure (STRU F)
       * * Additional settings for FTPS (PBSZ 0, PROT P)
       */
      async useDefaultSettings() {
          const features = await this.features();
          // Use MLSD directory listing if possible. See https://tools.ietf.org/html/rfc3659#section-7.8:
          // "The presence of the MLST feature indicates that both MLST and MLSD are supported."
          const supportsMLSD = features.has("MLST");
          this.availableListCommands = supportsMLSD ? LIST_COMMANDS_MLSD : LIST_COMMANDS_DEFAULT;
          await this.send("TYPE I"); // Binary mode
          await this.sendIgnoringError("STRU F"); // Use file structure
          await this.sendIgnoringError("OPTS UTF8 ON"); // Some servers expect UTF-8 to be enabled explicitly
          if (supportsMLSD) {
              await this.sendIgnoringError("OPTS MLST type;size;modify;unique;unix.mode;unix.owner;unix.group;unix.ownername;unix.groupname;"); // Make sure MLSD listings include all we can parse
          }
          if (this.ftp.hasTLS) {
              await this.sendIgnoringError("PBSZ 0"); // Set to 0 for TLS
              await this.sendIgnoringError("PROT P"); // Protect channel (also for data connections)
          }
      }
      /**
       * Convenience method that calls `connect`, `useTLS`, `login` and `useDefaultSettings`.
       *
       * This is an instance method and thus can be called multiple times during the lifecycle of a `Client`
       * instance. Whenever you do, the client is reset with a new control connection. This also implies that
       * you can reopen a `Client` instance that has been closed due to an error when reconnecting with this
       * method. In fact, reconnecting is the only way to continue using a closed `Client`.
       */
      async access(options = {}) {
          var _a, _b;
          const useExplicitTLS = options.secure === true;
          const useImplicitTLS = options.secure === "implicit";
          let welcome;
          if (useImplicitTLS) {
              welcome = await this.connectImplicitTLS(options.host, options.port, options.secureOptions);
          }
          else {
              welcome = await this.connect(options.host, options.port);
          }
          if (useExplicitTLS) {
              // Fixes https://github.com/patrickjuchli/basic-ftp/issues/166 by making sure
              // host is set for any future data connection as well.
              const secureOptions = (_a = options.secureOptions) !== null && _a !== void 0 ? _a : {};
              secureOptions.host = (_b = secureOptions.host) !== null && _b !== void 0 ? _b : options.host;
              await this.useTLS(secureOptions);
          }
          await this.login(options.user, options.password);
          await this.useDefaultSettings();
          return welcome;
      }
      /**
       * Get the current working directory.
       */
      async pwd() {
          const res = await this.send("PWD");
          // The directory is part of the return message, for example:
          // 257 "/this/that" is current directory.
          const parsed = res.message.match(/"(.+)"/);
          if (parsed === null || parsed[1] === undefined) {
              throw new Error(`Can't parse response to command 'PWD': ${res.message}`);
          }
          return parsed[1];
      }
      /**
       * Get a description of supported features.
       *
       * This sends the FEAT command and parses the result into a Map where keys correspond to available commands
       * and values hold further information. Be aware that your FTP servers might not support this
       * command in which case this method will not throw an exception but just return an empty Map.
       */
      async features() {
          const res = await this.sendIgnoringError("FEAT");
          const features = new Map();
          // Not supporting any special features will be reported with a single line.
          if (res.code < 400 && parseControlResponse_1.isMultiline(res.message)) {
              // The first and last line wrap the multiline response, ignore them.
              res.message.split("\n").slice(1, -1).forEach(line => {
                  // A typical lines looks like: " REST STREAM" or " MDTM".
                  // Servers might not use an indentation though.
                  const entry = line.trim().split(" ");
                  features.set(entry[0], entry[1] || "");
              });
          }
          return features;
      }
      /**
       * Set the working directory.
       */
      async cd(path) {
          const validPath = await this.protectWhitespace(path);
          return this.send("CWD " + validPath);
      }
      /**
       * Switch to the parent directory of the working directory.
       */
      async cdup() {
          return this.send("CDUP");
      }
      /**
       * Get the last modified time of a file. This is not supported by every FTP server, in which case
       * calling this method will throw an exception.
       */
      async lastMod(path) {
          const validPath = await this.protectWhitespace(path);
          const res = await this.send(`MDTM ${validPath}`);
          const date = res.message.slice(4);
          return parseListMLSD_1.parseMLSxDate(date);
      }
      /**
       * Get the size of a file.
       */
      async size(path) {
          const validPath = await this.protectWhitespace(path);
          const command = `SIZE ${validPath}`;
          const res = await this.send(command);
          // The size is part of the response message, for example: "213 555555". It's
          // possible that there is a commmentary appended like "213 5555, some commentary".
          const size = parseInt(res.message.slice(4), 10);
          if (Number.isNaN(size)) {
              throw new Error(`Can't parse response to command '${command}' as a numerical value: ${res.message}`);
          }
          return size;
      }
      /**
       * Rename a file.
       *
       * Depending on the FTP server this might also be used to move a file from one
       * directory to another by providing full paths.
       */
      async rename(srcPath, destPath) {
          const validSrc = await this.protectWhitespace(srcPath);
          const validDest = await this.protectWhitespace(destPath);
          await this.send("RNFR " + validSrc);
          return this.send("RNTO " + validDest);
      }
      /**
       * Remove a file from the current working directory.
       *
       * You can ignore FTP error return codes which won't throw an exception if e.g.
       * the file doesn't exist.
       */
      async remove(path, ignoreErrorCodes = false) {
          const validPath = await this.protectWhitespace(path);
          return this.send(`DELE ${validPath}`, ignoreErrorCodes);
      }
      /**
       * Report transfer progress for any upload or download to a given handler.
       *
       * This will also reset the overall transfer counter that can be used for multiple transfers. You can
       * also call the function without a handler to stop reporting to an earlier one.
       *
       * @param handler  Handler function to call on transfer progress.
       */
      trackProgress(handler) {
          this._progressTracker.bytesOverall = 0;
          this._progressTracker.reportTo(handler);
      }
      /**
       * Upload data from a readable stream or a local file to a remote file.
       *
       * @param source  Readable stream or path to a local file.
       * @param toRemotePath  Path to a remote file to write to.
       */
      async uploadFrom(source, toRemotePath, options = {}) {
          return this._uploadWithCommand(source, toRemotePath, "STOR", options);
      }
      /**
       * Upload data from a readable stream or a local file by appending it to an existing file. If the file doesn't
       * exist the FTP server should create it.
       *
       * @param source  Readable stream or path to a local file.
       * @param toRemotePath  Path to a remote file to write to.
       */
      async appendFrom(source, toRemotePath, options = {}) {
          return this._uploadWithCommand(source, toRemotePath, "APPE", options);
      }
      /**
       * @protected
       */
      async _uploadWithCommand(source, remotePath, command, options) {
          if (typeof source === "string") {
              return this._uploadLocalFile(source, remotePath, command, options);
          }
          return this._uploadFromStream(source, remotePath, command);
      }
      /**
       * @protected
       */
      async _uploadLocalFile(localPath, remotePath, command, options) {
          const fd = await fsOpen(localPath, "r");
          const source = fs_1.createReadStream("", {
              fd,
              start: options.localStart,
              end: options.localEndInclusive,
              autoClose: false
          });
          try {
              return await this._uploadFromStream(source, remotePath, command);
          }
          finally {
              await ignoreError(() => fsClose(fd));
          }
      }
      /**
       * @protected
       */
      async _uploadFromStream(source, remotePath, command) {
          const onError = (err) => this.ftp.closeWithError(err);
          source.once("error", onError);
          try {
              const validPath = await this.protectWhitespace(remotePath);
              await this.prepareTransfer(this.ftp);
              // Keep the keyword `await` or the `finally` clause below runs too early
              // and removes the event listener for the source stream too early.
              return await transfer_1.uploadFrom(source, {
                  ftp: this.ftp,
                  tracker: this._progressTracker,
                  command,
                  remotePath: validPath,
                  type: "upload"
              });
          }
          finally {
              source.removeListener("error", onError);
          }
      }
      /**
       * Download a remote file and pipe its data to a writable stream or to a local file.
       *
       * You can optionally define at which position of the remote file you'd like to start
       * downloading. If the destination you provide is a file, the offset will be applied
       * to it as well. For example: To resume a failed download, you'd request the size of
       * the local, partially downloaded file and use that as the offset. Assuming the size
       * is 23, you'd download the rest using `downloadTo("local.txt", "remote.txt", 23)`.
       *
       * @param destination  Stream or path for a local file to write to.
       * @param fromRemotePath  Path of the remote file to read from.
       * @param startAt  Position within the remote file to start downloading at. If the destination is a file, this offset is also applied to it.
       */
      async downloadTo(destination, fromRemotePath, startAt = 0) {
          if (typeof destination === "string") {
              return this._downloadToFile(destination, fromRemotePath, startAt);
          }
          return this._downloadToStream(destination, fromRemotePath, startAt);
      }
      /**
       * @protected
       */
      async _downloadToFile(localPath, remotePath, startAt) {
          const appendingToLocalFile = startAt > 0;
          const fileSystemFlags = appendingToLocalFile ? "r+" : "w";
          const fd = await fsOpen(localPath, fileSystemFlags);
          const destination = fs_1.createWriteStream("", {
              fd,
              start: startAt,
              autoClose: false
          });
          try {
              return await this._downloadToStream(destination, remotePath, startAt);
          }
          catch (err) {
              const localFileStats = await ignoreError(() => fsStat(localPath));
              const hasDownloadedData = localFileStats && localFileStats.size > 0;
              const shouldRemoveLocalFile = !appendingToLocalFile && !hasDownloadedData;
              if (shouldRemoveLocalFile) {
                  await ignoreError(() => fsUnlink(localPath));
              }
              throw err;
          }
          finally {
              await ignoreError(() => fsClose(fd));
          }
      }
      /**
       * @protected
       */
      async _downloadToStream(destination, remotePath, startAt) {
          const onError = (err) => this.ftp.closeWithError(err);
          destination.once("error", onError);
          try {
              const validPath = await this.protectWhitespace(remotePath);
              await this.prepareTransfer(this.ftp);
              // Keep the keyword `await` or the `finally` clause below runs too early
              // and removes the event listener for the source stream too early.
              return await transfer_1.downloadTo(destination, {
                  ftp: this.ftp,
                  tracker: this._progressTracker,
                  command: startAt > 0 ? `REST ${startAt}` : `RETR ${validPath}`,
                  remotePath: validPath,
                  type: "download"
              });
          }
          finally {
              destination.removeListener("error", onError);
              destination.end();
          }
      }
      /**
       * List files and directories in the current working directory, or from `path` if specified.
       *
       * @param [path]  Path to remote file or directory.
       */
      async list(path = "") {
          const validPath = await this.protectWhitespace(path);
          let lastError;
          for (const candidate of this.availableListCommands) {
              const command = validPath === "" ? candidate : `${candidate} ${validPath}`;
              await this.prepareTransfer(this.ftp);
              try {
                  const parsedList = await this._requestListWithCommand(command);
                  // Use successful candidate for all subsequent requests.
                  this.availableListCommands = [candidate];
                  return parsedList;
              }
              catch (err) {
                  const shouldTryNext = err instanceof FtpContext_1.FTPError;
                  if (!shouldTryNext) {
                      throw err;
                  }
                  lastError = err;
              }
          }
          throw lastError;
      }
      /**
       * @protected
       */
      async _requestListWithCommand(command) {
          const buffer = new StringWriter_1.StringWriter();
          await transfer_1.downloadTo(buffer, {
              ftp: this.ftp,
              tracker: this._progressTracker,
              command,
              remotePath: "",
              type: "list"
          });
          const text = buffer.getText(this.ftp.encoding);
          this.ftp.log(text);
          return this.parseList(text);
      }
      /**
       * Remove a directory and all of its content.
       *
       * @param remoteDirPath  The path of the remote directory to delete.
       * @example client.removeDir("foo") // Remove directory 'foo' using a relative path.
       * @example client.removeDir("foo/bar") // Remove directory 'bar' using a relative path.
       * @example client.removeDir("/foo/bar") // Remove directory 'bar' using an absolute path.
       * @example client.removeDir("/") // Remove everything.
       */
      async removeDir(remoteDirPath) {
          return this._exitAtCurrentDirectory(async () => {
              await this.cd(remoteDirPath);
              await this.clearWorkingDir();
              if (remoteDirPath !== "/") {
                  await this.cdup();
                  await this.removeEmptyDir(remoteDirPath);
              }
          });
      }
      /**
       * Remove all files and directories in the working directory without removing
       * the working directory itself.
       */
      async clearWorkingDir() {
          for (const file of await this.list()) {
              if (file.isDirectory) {
                  await this.cd(file.name);
                  await this.clearWorkingDir();
                  await this.cdup();
                  await this.removeEmptyDir(file.name);
              }
              else {
                  await this.remove(file.name);
              }
          }
      }
      /**
       * Upload the contents of a local directory to the remote working directory.
       *
       * This will overwrite existing files with the same names and reuse existing directories.
       * Unrelated files and directories will remain untouched. You can optionally provide a `remoteDirPath`
       * to put the contents inside a directory which will be created if necessary including all
       * intermediate directories. If you did provide a remoteDirPath the working directory will stay
       * the same as before calling this method.
       *
       * @param localDirPath  Local path, e.g. "foo/bar" or "../test"
       * @param [remoteDirPath]  Remote path of a directory to upload to. Working directory if undefined.
       */
      async uploadFromDir(localDirPath, remoteDirPath) {
          return this._exitAtCurrentDirectory(async () => {
              if (remoteDirPath) {
                  await this.ensureDir(remoteDirPath);
              }
              return await this._uploadToWorkingDir(localDirPath);
          });
      }
      /**
       * @protected
       */
      async _uploadToWorkingDir(localDirPath) {
          const files = await fsReadDir(localDirPath);
          for (const file of files) {
              const fullPath = path_1.join(localDirPath, file);
              const stats = await fsStat(fullPath);
              if (stats.isFile()) {
                  await this.uploadFrom(fullPath, file);
              }
              else if (stats.isDirectory()) {
                  await this._openDir(file);
                  await this._uploadToWorkingDir(fullPath);
                  await this.cdup();
              }
          }
      }
      /**
       * Download all files and directories of the working directory to a local directory.
       *
       * @param localDirPath  The local directory to download to.
       * @param remoteDirPath  Remote directory to download. Current working directory if not specified.
       */
      async downloadToDir(localDirPath, remoteDirPath) {
          return this._exitAtCurrentDirectory(async () => {
              if (remoteDirPath) {
                  await this.cd(remoteDirPath);
              }
              return await this._downloadFromWorkingDir(localDirPath);
          });
      }
      /**
       * @protected
       */
      async _downloadFromWorkingDir(localDirPath) {
          await ensureLocalDirectory(localDirPath);
          for (const file of await this.list()) {
              const localPath = path_1.join(localDirPath, file.name);
              if (file.isDirectory) {
                  await this.cd(file.name);
                  await this._downloadFromWorkingDir(localPath);
                  await this.cdup();
              }
              else if (file.isFile) {
                  await this.downloadTo(localPath, file.name);
              }
          }
      }
      /**
       * Make sure a given remote path exists, creating all directories as necessary.
       * This function also changes the current working directory to the given path.
       */
      async ensureDir(remoteDirPath) {
          // If the remoteDirPath was absolute go to root directory.
          if (remoteDirPath.startsWith("/")) {
              await this.cd("/");
          }
          const names = remoteDirPath.split("/").filter(name => name !== "");
          for (const name of names) {
              await this._openDir(name);
          }
      }
      /**
       * Try to create a directory and enter it. This will not raise an exception if the directory
       * couldn't be created if for example it already exists.
       * @protected
       */
      async _openDir(dirName) {
          await this.sendIgnoringError("MKD " + dirName);
          await this.cd(dirName);
      }
      /**
       * Remove an empty directory, will fail if not empty.
       */
      async removeEmptyDir(path) {
          const validPath = await this.protectWhitespace(path);
          return this.send(`RMD ${validPath}`);
      }
      /**
       * FTP servers can't handle filenames that have leading whitespace. This method transforms
       * a given path to fix that issue for most cases.
       */
      async protectWhitespace(path) {
          if (!path.startsWith(" ")) {
              return path;
          }
          // Handle leading whitespace by prepending the absolute path:
          // " test.txt" while being in the root directory becomes "/ test.txt".
          const pwd = await this.pwd();
          const absolutePathPrefix = pwd.endsWith("/") ? pwd : pwd + "/";
          return absolutePathPrefix + path;
      }
      async _exitAtCurrentDirectory(func) {
          const userDir = await this.pwd();
          try {
              return await func();
          }
          finally {
              if (!this.closed) {
                  await ignoreError(() => this.cd(userDir));
              }
          }
      }
      /**
       * Try all available transfer strategies and pick the first one that works. Update `client` to
       * use the working strategy for all successive transfer requests.
       *
       * @param transferModes
       * @returns a function that will try the provided strategies.
       */
      _enterFirstCompatibleMode(transferModes) {
          return async (ftp) => {
              ftp.log("Trying to find optimal transfer mode...");
              for (const transferMode of transferModes) {
                  try {
                      const res = await transferMode(ftp);
                      ftp.log("Optimal transfer mode found.");
                      this.prepareTransfer = transferMode; // eslint-disable-line require-atomic-updates
                      return res;
                  }
                  catch (err) {
                      // Try the next candidate no matter the exact error. It's possible that a server
                      // answered incorrectly to a strategy, for example a PASV answer to an EPSV.
                      ftp.log(`Transfer mode failed: "${err.message}", will try next.`);
                  }
              }
              throw new Error("None of the available transfer modes work.");
          };
      }
      /**
       * DEPRECATED, use `uploadFrom`.
       * @deprecated
       */
      async upload(source, toRemotePath, options = {}) {
          this.ftp.log("Warning: upload() has been deprecated, use uploadFrom().");
          return this.uploadFrom(source, toRemotePath, options);
      }
      /**
       * DEPRECATED, use `appendFrom`.
       * @deprecated
       */
      async append(source, toRemotePath, options = {}) {
          this.ftp.log("Warning: append() has been deprecated, use appendFrom().");
          return this.appendFrom(source, toRemotePath, options);
      }
      /**
       * DEPRECATED, use `downloadTo`.
       * @deprecated
       */
      async download(destination, fromRemotePath, startAt = 0) {
          this.ftp.log("Warning: download() has been deprecated, use downloadTo().");
          return this.downloadTo(destination, fromRemotePath, startAt);
      }
      /**
       * DEPRECATED, use `uploadFromDir`.
       * @deprecated
       */
      async uploadDir(localDirPath, remoteDirPath) {
          this.ftp.log("Warning: uploadDir() has been deprecated, use uploadFromDir().");
          return this.uploadFromDir(localDirPath, remoteDirPath);
      }
      /**
       * DEPRECATED, use `downloadToDir`.
       * @deprecated
       */
      async downloadDir(localDirPath) {
          this.ftp.log("Warning: downloadDir() has been deprecated, use downloadToDir().");
          return this.downloadToDir(localDirPath);
      }
  }
  exports.Client = Client;
  async function ensureLocalDirectory(path) {
      try {
          await fsStat(path);
      }
      catch (err) {
          await fsMkDir(path, { recursive: true });
      }
  }
  async function ignoreError(func) {
      try {
          return await func();
      }
      catch (err) {
          // Ignore
          return undefined;
      }
  }
  
  
  /***/ }),
  
  /***/ 202:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.FileInfo = exports.FileType = void 0;
  var FileType;
  (function (FileType) {
      FileType[FileType["Unknown"] = 0] = "Unknown";
      FileType[FileType["File"] = 1] = "File";
      FileType[FileType["Directory"] = 2] = "Directory";
      FileType[FileType["SymbolicLink"] = 3] = "SymbolicLink";
  })(FileType = exports.FileType || (exports.FileType = {}));
  /**
   * Describes a file, directory or symbolic link.
   */
  class FileInfo {
      constructor(name) {
          this.name = name;
          this.type = FileType.Unknown;
          this.size = 0;
          /**
           * Unparsed, raw modification date as a string.
           *
           * If `modifiedAt` is undefined, the FTP server you're connected to doesn't support the more modern
           * MLSD command for machine-readable directory listings. The older command LIST is then used returning
           * results that vary a lot between servers as the format hasn't been standardized. Here, directory listings
           * and especially modification dates were meant to be human-readable first.
           *
           * Be careful when still trying to parse this by yourself. Parsing dates from listings using LIST is
           * unreliable. This library decides to offer parsed dates only when they're absolutely reliable and safe to
           * use e.g. for comparisons.
           */
          this.rawModifiedAt = "";
          /**
           * Parsed modification date.
           *
           * Available if the FTP server supports the MLSD command. Only MLSD guarantees dates than can be reliably
           * parsed with the correct timezone and a resolution down to seconds. See `rawModifiedAt` property for the unparsed
           * date that is always available.
           */
          this.modifiedAt = undefined;
          /**
           * Unix permissions if present. If the underlying FTP server is not running on Unix this will be undefined.
           * If set, you might be able to edit permissions with the FTP command `SITE CHMOD`.
           */
          this.permissions = undefined;
          /**
           * Hard link count if available.
           */
          this.hardLinkCount = undefined;
          /**
           * Link name for symbolic links if available.
           */
          this.link = undefined;
          /**
           * Unix group if available.
           */
          this.group = undefined;
          /**
           * Unix user if available.
           */
          this.user = undefined;
          /**
           * Unique ID if available.
           */
          this.uniqueID = undefined;
          this.name = name;
      }
      get isDirectory() {
          return this.type === FileType.Directory;
      }
      get isSymbolicLink() {
          return this.type === FileType.SymbolicLink;
      }
      get isFile() {
          return this.type === FileType.File;
      }
      /**
       * Deprecated, legacy API. Use `rawModifiedAt` instead.
       * @deprecated
       */
      get date() {
          return this.rawModifiedAt;
      }
      set date(rawModifiedAt) {
          this.rawModifiedAt = rawModifiedAt;
      }
  }
  exports.FileInfo = FileInfo;
  FileInfo.UnixPermission = {
      Read: 4,
      Write: 2,
      Execute: 1
  };
  
  
  /***/ }),
  
  /***/ 9052:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.FTPContext = exports.FTPError = void 0;
  const net_1 = __nccwpck_require__(1631);
  const parseControlResponse_1 = __nccwpck_require__(9948);
  /**
   * Describes an FTP server error response including the FTP response code.
   */
  class FTPError extends Error {
      constructor(res) {
          super(res.message);
          this.name = this.constructor.name;
          this.code = res.code;
      }
  }
  exports.FTPError = FTPError;
  /**
   * FTPContext holds the control and data sockets of an FTP connection and provides a
   * simplified way to interact with an FTP server, handle responses, errors and timeouts.
   *
   * It doesn't implement or use any FTP commands. It's only a foundation to make writing an FTP
   * client as easy as possible. You won't usually instantiate this, but use `Client`.
   */
  class FTPContext {
      /**
       * Instantiate an FTP context.
       *
       * @param timeout - Timeout in milliseconds to apply to control and data connections. Use 0 for no timeout.
       * @param encoding - Encoding to use for control connection. UTF-8 by default. Use "latin1" for older servers.
       */
      constructor(timeout = 0, encoding = "utf8") {
          this.timeout = timeout;
          /** Debug-level logging of all socket communication. */
          this.verbose = false;
          /** IP version to prefer (4: IPv4, 6: IPv6, undefined: automatic). */
          this.ipFamily = undefined;
          /** Options for TLS connections. */
          this.tlsOptions = {};
          /** A multiline response might be received as multiple chunks. */
          this._partialResponse = "";
          this._encoding = encoding;
          // Help Typescript understand that we do indeed set _socket in the constructor but use the setter method to do so.
          this._socket = this.socket = this._newSocket();
          this._dataSocket = undefined;
      }
      /**
       * Close the context.
       */
      close() {
          // Internally, closing a context is always described with an error. If there is still a task running, it will
          // abort with an exception that the user closed the client during a task. If no task is running, no exception is
          // thrown but all newly submitted tasks after that will abort the exception that the client has been closed.
          // In addition the user will get a stack trace pointing to where exactly the client has been closed. So in any
          // case use _closingError to determine whether a context is closed. This also allows us to have a single code-path
          // for closing a context making the implementation easier.
          const message = this._task ? "User closed client during task" : "User closed client";
          const err = new Error(message);
          this.closeWithError(err);
      }
      /**
       * Close the context with an error.
       */
      closeWithError(err) {
          // If this context already has been closed, don't overwrite the reason.
          if (this._closingError) {
              return;
          }
          this._closingError = err;
          // Before giving the user's task a chance to react, make sure we won't be bothered with any inputs.
          this._closeSocket(this._socket);
          this._closeSocket(this._dataSocket);
          // Give the user's task a chance to react, maybe cleanup resources.
          this._passToHandler(err);
          // The task might not have been rejected by the user after receiving the error.
          this._stopTrackingTask();
      }
      /**
       * Returns true if this context has been closed or hasn't been connected yet. You can reopen it with `access`.
       */
      get closed() {
          return this.socket.remoteAddress === undefined || this._closingError !== undefined;
      }
      /**
       * Reset this contex and all of its state.
       */
      reset() {
          this.socket = this._newSocket();
      }
      /**
       * Get the FTP control socket.
       */
      get socket() {
          return this._socket;
      }
      /**
       * Set the socket for the control connection. This will only close the current control socket
       * if the new one is not an upgrade to the current one.
       */
      set socket(socket) {
          // No data socket should be open in any case where the control socket is set or upgraded.
          this.dataSocket = undefined;
          this.tlsOptions = {};
          // This being a soft reset, remove any remaining partial response.
          this._partialResponse = "";
          if (this._socket) {
              // Only close the current connection if the new is not an upgrade.
              const isUpgrade = socket.localPort === this._socket.localPort;
              if (!isUpgrade) {
                  this._socket.destroy();
              }
              this._removeSocketListeners(this._socket);
          }
          if (socket) {
              // Setting a completely new control socket is in essence something like a reset. That's
              // why we also close any open data connection above. We can go one step further and reset
              // a possible closing error. That means that a closed FTPContext can be "reopened" by
              // setting a new control socket.
              this._closingError = undefined;
              // Don't set a timeout yet. Timeout for control sockets is only active during a task, see handle() below.
              socket.setTimeout(0);
              socket.setEncoding(this._encoding);
              socket.setKeepAlive(true);
              socket.on("data", data => this._onControlSocketData(data));
              // Server sending a FIN packet is treated as an error.
              socket.on("end", () => this.closeWithError(new Error("Server sent FIN packet unexpectedly, closing connection.")));
              // Control being closed without error by server is treated as an error.
              socket.on("close", hadError => { if (!hadError)
                  this.closeWithError(new Error("Server closed connection unexpectedly.")); });
              this._setupDefaultErrorHandlers(socket, "control socket");
          }
          this._socket = socket;
      }
      /**
       * Get the current FTP data connection if present.
       */
      get dataSocket() {
          return this._dataSocket;
      }
      /**
       * Set the socket for the data connection. This will automatically close the former data socket.
       */
      set dataSocket(socket) {
          this._closeSocket(this._dataSocket);
          if (socket) {
              // Don't set a timeout yet. Timeout data socket should be activated when data transmission starts
              // and timeout on control socket is deactivated.
              socket.setTimeout(0);
              this._setupDefaultErrorHandlers(socket, "data socket");
          }
          this._dataSocket = socket;
      }
      /**
       * Get the currently used encoding.
       */
      get encoding() {
          return this._encoding;
      }
      /**
       * Set the encoding used for the control socket.
       *
       * See https://nodejs.org/api/buffer.html#buffer_buffers_and_character_encodings for what encodings
       * are supported by Node.
       */
      set encoding(encoding) {
          this._encoding = encoding;
          if (this.socket) {
              this.socket.setEncoding(encoding);
          }
      }
      /**
       * Send an FTP command without waiting for or handling the result.
       */
      send(command) {
          const containsPassword = command.startsWith("PASS");
          const message = containsPassword ? "> PASS ###" : `> ${command}`;
          this.log(message);
          this._socket.write(command + "\r\n", this.encoding);
      }
      /**
       * Send an FTP command and handle the first response. Use this if you have a simple
       * request-response situation.
       */
      request(command) {
          return this.handle(command, (res, task) => {
              if (res instanceof Error) {
                  task.reject(res);
              }
              else {
                  task.resolve(res);
              }
          });
      }
      /**
       * Send an FTP command and handle any response until you resolve/reject. Use this if you expect multiple responses
       * to a request. This returns a Promise that will hold whatever the response handler passed on when resolving/rejecting its task.
       */
      handle(command, responseHandler) {
          if (this._task) {
              // The user or client instance called `handle()` while a task is still running.
              const err = new Error("User launched a task while another one is still running. Forgot to use 'await' or '.then()'?");
              err.stack += `\nRunning task launched at: ${this._task.stack}`;
              this.closeWithError(err);
              // Don't return here, continue with returning the Promise that will then be rejected
              // because the context closed already. That way, users will receive an exception where
              // they called this method by mistake.
          }
          return new Promise((resolvePromise, rejectPromise) => {
              const stack = new Error().stack || "Unknown call stack";
              const resolver = {
                  resolve: (arg) => {
                      this._stopTrackingTask();
                      resolvePromise(arg);
                  },
                  reject: err => {
                      this._stopTrackingTask();
                      rejectPromise(err);
                  }
              };
              this._task = {
                  stack,
                  resolver,
                  responseHandler
              };
              if (this._closingError) {
                  // This client has been closed. Provide an error that describes this one as being caused
                  // by `_closingError`, include stack traces for both.
                  const err = new Error("Client is closed"); // Type 'Error' is not correctly defined, doesn't have 'code'.
                  err.stack += `\nClosing reason: ${this._closingError.stack}`;
                  err.code = this._closingError.code !== undefined ? this._closingError.code : "0";
                  this._passToHandler(err);
                  return;
              }
              // Only track control socket timeout during the lifecycle of a task. This avoids timeouts on idle sockets,
              // the default socket behaviour which is not expected by most users.
              this.socket.setTimeout(this.timeout);
              if (command) {
                  this.send(command);
              }
          });
      }
      /**
       * Log message if set to be verbose.
       */
      log(message) {
          if (this.verbose) {
              // tslint:disable-next-line no-console
              console.log(message);
          }
      }
      /**
       * Return true if the control socket is using TLS. This does not mean that a session
       * has already been negotiated.
       */
      get hasTLS() {
          return "encrypted" in this._socket;
      }
      /**
       * Removes reference to current task and handler. This won't resolve or reject the task.
       * @protected
       */
      _stopTrackingTask() {
          // Disable timeout on control socket if there is no task active.
          this.socket.setTimeout(0);
          this._task = undefined;
      }
      /**
       * Handle incoming data on the control socket. The chunk is going to be of type `string`
       * because we let `socket` handle encoding with `setEncoding`.
       * @protected
       */
      _onControlSocketData(chunk) {
          this.log(`< ${chunk}`);
          // This chunk might complete an earlier partial response.
          const completeResponse = this._partialResponse + chunk;
          const parsed = parseControlResponse_1.parseControlResponse(completeResponse);
          // Remember any incomplete remainder.
          this._partialResponse = parsed.rest;
          // Each response group is passed along individually.
          for (const message of parsed.messages) {
              const code = parseInt(message.substr(0, 3), 10);
              const response = { code, message };
              const err = code >= 400 ? new FTPError(response) : undefined;
              this._passToHandler(err ? err : response);
          }
      }
      /**
       * Send the current handler a response. This is usually a control socket response
       * or a socket event, like an error or timeout.
       * @protected
       */
      _passToHandler(response) {
          if (this._task) {
              this._task.responseHandler(response, this._task.resolver);
          }
          // Errors other than FTPError always close the client. If there isn't an active task to handle the error,
          // the next one submitted will receive it using `_closingError`.
          // There is only one edge-case: If there is an FTPError while no task is active, the error will be dropped.
          // But that means that the user sent an FTP command with no intention of handling the result. So why should the
          // error be handled? Maybe log it at least? Debug logging will already do that and the client stays useable after
          // FTPError. So maybe no need to do anything here.
      }
      /**
       * Setup all error handlers for a socket.
       * @protected
       */
      _setupDefaultErrorHandlers(socket, identifier) {
          socket.once("error", error => {
              error.message += ` (${identifier})`;
              this.closeWithError(error);
          });
          socket.once("close", hadError => {
              if (hadError) {
                  this.closeWithError(new Error(`Socket closed due to transmission error (${identifier})`));
              }
          });
          socket.once("timeout", () => this.closeWithError(new Error(`Timeout (${identifier})`)));
      }
      /**
       * Close a socket.
       * @protected
       */
      _closeSocket(socket) {
          if (socket) {
              socket.destroy();
              this._removeSocketListeners(socket);
          }
      }
      /**
       * Remove all default listeners for socket.
       * @protected
       */
      _removeSocketListeners(socket) {
          socket.removeAllListeners();
          // Before Node.js 10.3.0, using `socket.removeAllListeners()` without any name did not work: https://github.com/nodejs/node/issues/20923.
          socket.removeAllListeners("timeout");
          socket.removeAllListeners("data");
          socket.removeAllListeners("end");
          socket.removeAllListeners("error");
          socket.removeAllListeners("close");
          socket.removeAllListeners("connect");
      }
      /**
       * Provide a new socket instance.
       *
       * Internal use only, replaced for unit tests.
       */
      _newSocket() {
          return new net_1.Socket();
      }
  }
  exports.FTPContext = FTPContext;
  
  
  /***/ }),
  
  /***/ 7170:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.ProgressTracker = void 0;
  /**
   * Tracks progress of one socket data transfer at a time.
   */
  class ProgressTracker {
      constructor() {
          this.bytesOverall = 0;
          this.intervalMs = 500;
          this.onStop = noop;
          this.onHandle = noop;
      }
      /**
       * Register a new handler for progress info. Use `undefined` to disable reporting.
       */
      reportTo(onHandle = noop) {
          this.onHandle = onHandle;
      }
      /**
       * Start tracking transfer progress of a socket.
       *
       * @param socket  The socket to observe.
       * @param name  A name associated with this progress tracking, e.g. a filename.
       * @param type  The type of the transfer, typically "upload" or "download".
       */
      start(socket, name, type) {
          let lastBytes = 0;
          this.onStop = poll(this.intervalMs, () => {
              const bytes = socket.bytesRead + socket.bytesWritten;
              this.bytesOverall += bytes - lastBytes;
              lastBytes = bytes;
              this.onHandle({
                  name,
                  type,
                  bytes,
                  bytesOverall: this.bytesOverall
              });
          });
      }
      /**
       * Stop tracking transfer progress.
       */
      stop() {
          this.onStop(false);
      }
      /**
       * Call the progress handler one more time, then stop tracking.
       */
      updateAndStop() {
          this.onStop(true);
      }
  }
  exports.ProgressTracker = ProgressTracker;
  /**
   * Starts calling a callback function at a regular interval. The first call will go out
   * immediately. The function returns a function to stop the polling.
   */
  function poll(intervalMs, updateFunc) {
      const id = setInterval(updateFunc, intervalMs);
      const stopFunc = (stopWithUpdate) => {
          clearInterval(id);
          if (stopWithUpdate) {
              updateFunc();
          }
          // Prevent repeated calls to stop calling handler.
          updateFunc = noop;
      };
      updateFunc();
      return stopFunc;
  }
  function noop() { }
  
  
  /***/ }),
  
  /***/ 4677:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  
  
  /***/ }),
  
  /***/ 8184:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.StringWriter = void 0;
  const stream_1 = __nccwpck_require__(2413);
  class StringWriter extends stream_1.Writable {
      constructor() {
          super(...arguments);
          this.buf = Buffer.alloc(0);
      }
      _write(chunk, _, callback) {
          if (chunk instanceof Buffer) {
              this.buf = Buffer.concat([this.buf, chunk]);
              callback(null);
          }
          else {
              callback(new Error("StringWriter expects chunks of type 'Buffer'."));
          }
      }
      getText(encoding) {
          return this.buf.toString(encoding);
      }
  }
  exports.StringWriter = StringWriter;
  
  
  /***/ }),
  
  /***/ 7957:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __exportStar = (this && this.__exportStar) || function(m, exports) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.enterPassiveModeIPv6 = exports.enterPassiveModeIPv4 = void 0;
  /**
   * Public API
   */
  __exportStar(__nccwpck_require__(8337), exports);
  __exportStar(__nccwpck_require__(9052), exports);
  __exportStar(__nccwpck_require__(202), exports);
  __exportStar(__nccwpck_require__(2993), exports);
  __exportStar(__nccwpck_require__(4677), exports);
  var transfer_1 = __nccwpck_require__(5803);
  Object.defineProperty(exports, "enterPassiveModeIPv4", ({ enumerable: true, get: function () { return transfer_1.enterPassiveModeIPv4; } }));
  Object.defineProperty(exports, "enterPassiveModeIPv6", ({ enumerable: true, get: function () { return transfer_1.enterPassiveModeIPv6; } }));
  
  
  /***/ }),
  
  /***/ 6288:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.ipIsPrivateV4Address = exports.upgradeSocket = exports.describeAddress = exports.describeTLS = void 0;
  const tls_1 = __nccwpck_require__(4016);
  /**
   * Returns a string describing the encryption on a given socket instance.
   */
  function describeTLS(socket) {
      if (socket instanceof tls_1.TLSSocket) {
          const protocol = socket.getProtocol();
          return protocol ? protocol : "Server socket or disconnected client socket";
      }
      return "No encryption";
  }
  exports.describeTLS = describeTLS;
  /**
   * Returns a string describing the remote address of a socket.
   */
  function describeAddress(socket) {
      if (socket.remoteFamily === "IPv6") {
          return `[${socket.remoteAddress}]:${socket.remotePort}`;
      }
      return `${socket.remoteAddress}:${socket.remotePort}`;
  }
  exports.describeAddress = describeAddress;
  /**
   * Upgrade a socket connection with TLS.
   */
  function upgradeSocket(socket, options) {
      return new Promise((resolve, reject) => {
          const tlsOptions = Object.assign({}, options, {
              socket
          });
          const tlsSocket = tls_1.connect(tlsOptions, () => {
              const expectCertificate = tlsOptions.rejectUnauthorized !== false;
              if (expectCertificate && !tlsSocket.authorized) {
                  reject(tlsSocket.authorizationError);
              }
              else {
                  // Remove error listener added below.
                  tlsSocket.removeAllListeners("error");
                  resolve(tlsSocket);
              }
          }).once("error", error => {
              reject(error);
          });
      });
  }
  exports.upgradeSocket = upgradeSocket;
  /**
   * Returns true if an IP is a private address according to https://tools.ietf.org/html/rfc1918#section-3.
   * This will handle IPv4-mapped IPv6 addresses correctly but return false for all other IPv6 addresses.
   *
   * @param ip  The IP as a string, e.g. "192.168.0.1"
   */
  function ipIsPrivateV4Address(ip = "") {
      // Handle IPv4-mapped IPv6 addresses like ::ffff:192.168.0.1
      if (ip.startsWith("::ffff:")) {
          ip = ip.substr(7); // Strip ::ffff: prefix
      }
      const octets = ip.split(".").map(o => parseInt(o, 10));
      return octets[0] === 10 // 10.0.0.0 - 10.255.255.255
          || (octets[0] === 172 && octets[1] >= 16 && octets[1] <= 31) // 172.16.0.0 - 172.31.255.255
          || (octets[0] === 192 && octets[1] === 168); // 192.168.0.0 - 192.168.255.255
  }
  exports.ipIsPrivateV4Address = ipIsPrivateV4Address;
  
  
  /***/ }),
  
  /***/ 9948:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.positiveIntermediate = exports.positiveCompletion = exports.isMultiline = exports.isSingleLine = exports.parseControlResponse = void 0;
  const LF = "\n";
  /**
   * Parse an FTP control response as a collection of messages. A message is a complete
   * single- or multiline response. A response can also contain multiple multiline responses
   * that will each be represented by a message. A response can also be incomplete
   * and be completed on the next incoming data chunk for which case this function also
   * describes a `rest`. This function converts all CRLF to LF.
   */
  function parseControlResponse(text) {
      const lines = text.split(/\r?\n/).filter(isNotBlank);
      const messages = [];
      let startAt = 0;
      let tokenRegex;
      for (let i = 0; i < lines.length; i++) {
          const line = lines[i];
          // No group has been opened.
          if (!tokenRegex) {
              if (isMultiline(line)) {
                  // Open a group by setting an expected token.
                  const token = line.substr(0, 3);
                  tokenRegex = new RegExp(`^${token}(?:$| )`);
                  startAt = i;
              }
              else if (isSingleLine(line)) {
                  // Single lines can be grouped immediately.
                  messages.push(line);
              }
          }
          // Group has been opened, expect closing token.
          else if (tokenRegex.test(line)) {
              tokenRegex = undefined;
              messages.push(lines.slice(startAt, i + 1).join(LF));
          }
      }
      // The last group might not have been closed, report it as a rest.
      const rest = tokenRegex ? lines.slice(startAt).join(LF) + LF : "";
      return { messages, rest };
  }
  exports.parseControlResponse = parseControlResponse;
  function isSingleLine(line) {
      return /^\d\d\d(?:$| )/.test(line);
  }
  exports.isSingleLine = isSingleLine;
  function isMultiline(line) {
      return /^\d\d\d-/.test(line);
  }
  exports.isMultiline = isMultiline;
  /**
   * Return true if an FTP return code describes a positive completion.
   */
  function positiveCompletion(code) {
      return code >= 200 && code < 300;
  }
  exports.positiveCompletion = positiveCompletion;
  /**
   * Return true if an FTP return code describes a positive intermediate response.
   */
  function positiveIntermediate(code) {
      return code >= 300 && code < 400;
  }
  exports.positiveIntermediate = positiveIntermediate;
  function isNotBlank(str) {
      return str.trim() !== "";
  }
  
  
  /***/ }),
  
  /***/ 2993:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.parseList = void 0;
  const dosParser = __importStar(__nccwpck_require__(6199));
  const unixParser = __importStar(__nccwpck_require__(2622));
  const mlsdParser = __importStar(__nccwpck_require__(8157));
  /**
   * Available directory listing parsers. These are candidates that will be tested
   * in the order presented. The first candidate will be used to parse the whole list.
   */
  const availableParsers = [
      dosParser,
      unixParser,
      mlsdParser // Keep MLSD last, may accept filename only
  ];
  function firstCompatibleParser(line, parsers) {
      return parsers.find(parser => parser.testLine(line) === true);
  }
  function stringIsNotBlank(str) {
      return str.trim() !== "";
  }
  const REGEX_NEWLINE = /\r?\n/;
  /**
   * Parse raw directory listing.
   */
  function parseList(rawList) {
      const lines = rawList
          .split(REGEX_NEWLINE)
          .filter(stringIsNotBlank);
      if (lines.length === 0) {
          return [];
      }
      const testLine = lines[lines.length - 1];
      const parser = firstCompatibleParser(testLine, availableParsers);
      if (!parser) {
          throw new Error("This library only supports MLSD, Unix- or DOS-style directory listing. Your FTP server seems to be using another format. You can see the transmitted listing when setting `client.ftp.verbose = true`. You can then provide a custom parser to `client.parseList`, see the documentation for details.");
      }
      const files = lines
          .map(parser.parseLine)
          .filter((info) => info !== undefined);
      return parser.transformList(files);
  }
  exports.parseList = parseList;
  
  
  /***/ }),
  
  /***/ 6199:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.transformList = exports.parseLine = exports.testLine = void 0;
  const FileInfo_1 = __nccwpck_require__(202);
  /**
   * This parser is based on the FTP client library source code in Apache Commons Net provided
   * under the Apache 2.0 license. It has been simplified and rewritten to better fit the Javascript language.
   *
   * https://github.com/apache/commons-net/blob/master/src/main/java/org/apache/commons/net/ftp/parser/NTFTPEntryParser.java
   */
  const RE_LINE = new RegExp("(\\S+)\\s+(\\S+)\\s+" // MM-dd-yy whitespace hh:mma|kk:mm swallow trailing spaces
      + "(?:(<DIR>)|([0-9]+))\\s+" // <DIR> or ddddd swallow trailing spaces
      + "(\\S.*)" // First non-space followed by rest of line (name)
  );
  /**
   * Returns true if a given line might be a DOS-style listing.
   *
   * - Example: `12-05-96  05:03PM       <DIR>          myDir`
   */
  function testLine(line) {
      return /^\d{2}/.test(line) && RE_LINE.test(line);
  }
  exports.testLine = testLine;
  /**
   * Parse a single line of a DOS-style directory listing.
   */
  function parseLine(line) {
      const groups = line.match(RE_LINE);
      if (groups === null) {
          return undefined;
      }
      const name = groups[5];
      if (name === "." || name === "..") { // Ignore parent directory links
          return undefined;
      }
      const file = new FileInfo_1.FileInfo(name);
      const fileType = groups[3];
      if (fileType === "<DIR>") {
          file.type = FileInfo_1.FileType.Directory;
          file.size = 0;
      }
      else {
          file.type = FileInfo_1.FileType.File;
          file.size = parseInt(groups[4], 10);
      }
      file.rawModifiedAt = groups[1] + " " + groups[2];
      return file;
  }
  exports.parseLine = parseLine;
  function transformList(files) {
      return files;
  }
  exports.transformList = transformList;
  
  
  /***/ }),
  
  /***/ 8157:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.parseMLSxDate = exports.transformList = exports.parseLine = exports.testLine = void 0;
  const FileInfo_1 = __nccwpck_require__(202);
  function parseSize(value, info) {
      info.size = parseInt(value, 10);
  }
  /**
   * Parsers for MLSD facts.
   */
  const factHandlersByName = {
      "size": parseSize,
      "sizd": parseSize,
      "unique": (value, info) => {
          info.uniqueID = value;
      },
      "modify": (value, info) => {
          info.modifiedAt = parseMLSxDate(value);
          info.rawModifiedAt = info.modifiedAt.toISOString();
      },
      "type": (value, info) => {
          // There seems to be confusion on how to handle symbolic links for Unix. RFC 3659 doesn't describe
          // this but mentions some examples using the syntax `type=OS.unix=slink:<target>`. But according to
          // an entry in the Errata (https://www.rfc-editor.org/errata/eid1500) this syntax can't be valid.
          // Instead it proposes to use `type=OS.unix=symlink` and to then list the actual target of the
          // symbolic link as another entry in the directory listing. The unique identifiers can then be used
          // to derive the connection between link(s) and target. We'll have to handle both cases as there
          // are differing opinions on how to deal with this. Here are some links on this topic:
          // - ProFTPD source: https://github.com/proftpd/proftpd/blob/56e6dfa598cbd4ef5c6cba439bcbcd53a63e3b21/modules/mod_facts.c#L531
          // - ProFTPD bug: http://bugs.proftpd.org/show_bug.cgi?id=3318
          // - ProFTPD statement: http://www.proftpd.org/docs/modules/mod_facts.html
          // – FileZilla bug: https://trac.filezilla-project.org/ticket/9310
          if (value.startsWith("OS.unix=slink")) {
              info.type = FileInfo_1.FileType.SymbolicLink;
              info.link = value.substr(value.indexOf(":") + 1);
              return 1 /* Continue */;
          }
          switch (value) {
              case "file":
                  info.type = FileInfo_1.FileType.File;
                  break;
              case "dir":
                  info.type = FileInfo_1.FileType.Directory;
                  break;
              case "OS.unix=symlink":
                  info.type = FileInfo_1.FileType.SymbolicLink;
                  // The target of the symbolic link might be defined in another line in the directory listing.
                  // We'll handle this in `transformList()` below.
                  break;
              case "cdir": // Current directory being listed
              case "pdir": // Parent directory
                  return 2 /* IgnoreFile */; // Don't include these entries in the listing
              default:
                  info.type = FileInfo_1.FileType.Unknown;
          }
          return 1 /* Continue */;
      },
      "unix.mode": (value, info) => {
          const digits = value.substr(-3);
          info.permissions = {
              user: parseInt(digits[0], 10),
              group: parseInt(digits[1], 10),
              world: parseInt(digits[2], 10)
          };
      },
      "unix.ownername": (value, info) => {
          info.user = value;
      },
      "unix.owner": (value, info) => {
          if (info.user === undefined)
              info.user = value;
      },
      get "unix.uid"() {
          return this["unix.owner"];
      },
      "unix.groupname": (value, info) => {
          info.group = value;
      },
      "unix.group": (value, info) => {
          if (info.group === undefined)
              info.group = value;
      },
      get "unix.gid"() {
          return this["unix.group"];
      }
      // Regarding the fact "perm":
      // We don't handle permission information stored in "perm" because its information is conceptually
      // different from what users of FTP clients usually associate with "permissions". Those that have
      // some expectations (and probably want to edit them with a SITE command) often unknowingly expect
      // the Unix permission system. The information passed by "perm" describes what FTP commands can be
      // executed with a file/directory. But even this can be either incomplete or just meant as a "guide"
      // as the spec mentions. From https://tools.ietf.org/html/rfc3659#section-7.5.5: "The permissions are
      // described here as they apply to FTP commands. They may not map easily into particular permissions
      // available on the server's operating system." The parser by Apache Commons tries to translate these
      // to Unix permissions – this is misleading users and might not even be correct.
  };
  /**
   * Split a string once at the first position of a delimiter. For example
   * `splitStringOnce("a b c d", " ")` returns `["a", "b c d"]`.
   */
  function splitStringOnce(str, delimiter) {
      const pos = str.indexOf(delimiter);
      const a = str.substr(0, pos);
      const b = str.substr(pos + delimiter.length);
      return [a, b];
  }
  /**
   * Returns true if a given line might be part of an MLSD listing.
   *
   * - Example 1: `size=15227;type=dir;perm=el;modify=20190419065730; test one`
   * - Example 2: ` file name` (leading space)
   */
  function testLine(line) {
      return /^\S+=\S+;/.test(line) || line.startsWith(" ");
  }
  exports.testLine = testLine;
  /**
   * Parse single line as MLSD listing, see specification at https://tools.ietf.org/html/rfc3659#section-7.
   */
  function parseLine(line) {
      const [packedFacts, name] = splitStringOnce(line, " ");
      if (name === "" || name === "." || name === "..") {
          return undefined;
      }
      const info = new FileInfo_1.FileInfo(name);
      const facts = packedFacts.split(";");
      for (const fact of facts) {
          const [factName, factValue] = splitStringOnce(fact, "=");
          if (!factValue) {
              continue;
          }
          const factHandler = factHandlersByName[factName.toLowerCase()];
          if (!factHandler) {
              continue;
          }
          const result = factHandler(factValue, info);
          if (result === 2 /* IgnoreFile */) {
              return undefined;
          }
      }
      return info;
  }
  exports.parseLine = parseLine;
  function transformList(files) {
      // Create a map of all files that are not symbolic links by their unique ID
      const nonLinksByID = new Map();
      for (const file of files) {
          if (!file.isSymbolicLink && file.uniqueID !== undefined) {
              nonLinksByID.set(file.uniqueID, file);
          }
      }
      const resolvedFiles = [];
      for (const file of files) {
          // Try to associate unresolved symbolic links with a target file/directory.
          if (file.isSymbolicLink && file.uniqueID !== undefined && file.link === undefined) {
              const target = nonLinksByID.get(file.uniqueID);
              if (target !== undefined) {
                  file.link = target.name;
              }
          }
          // The target of a symbolic link is listed as an entry in the directory listing but might
          // have a path pointing outside of this directory. In that case we don't want this entry
          // to be part of the listing. We generally don't want these kind of entries at all.
          const isPartOfDirectory = !file.name.includes("/");
          if (isPartOfDirectory) {
              resolvedFiles.push(file);
          }
      }
      return resolvedFiles;
  }
  exports.transformList = transformList;
  /**
   * Parse date as specified in https://tools.ietf.org/html/rfc3659#section-2.3.
   *
   * Message contains response code and modified time in the format: YYYYMMDDHHMMSS[.sss]
   * For example `19991005213102` or `19980615100045.014`.
   */
  function parseMLSxDate(fact) {
      return new Date(Date.UTC(+fact.slice(0, 4), // Year
      +fact.slice(4, 6) - 1, // Month
      +fact.slice(6, 8), // Date
      +fact.slice(8, 10), // Hours
      +fact.slice(10, 12), // Minutes
      +fact.slice(12, 14), // Seconds
      +fact.slice(15, 18) // Milliseconds
      ));
  }
  exports.parseMLSxDate = parseMLSxDate;
  
  
  /***/ }),
  
  /***/ 2622:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.transformList = exports.parseLine = exports.testLine = void 0;
  const FileInfo_1 = __nccwpck_require__(202);
  const JA_MONTH = "\u6708";
  const JA_DAY = "\u65e5";
  const JA_YEAR = "\u5e74";
  /**
   * This parser is based on the FTP client library source code in Apache Commons Net provided
   * under the Apache 2.0 license. It has been simplified and rewritten to better fit the Javascript language.
   *
   * https://github.com/apache/commons-net/blob/master/src/main/java/org/apache/commons/net/ftp/parser/UnixFTPEntryParser.java
   *
   * Below is the regular expression used by this parser.
   *
   * Permissions:
   *    r   the file is readable
   *    w   the file is writable
   *    x   the file is executable
   *    -   the indicated permission is not granted
   *    L   mandatory locking occurs during access (the set-group-ID bit is
   *        on and the group execution bit is off)
   *    s   the set-user-ID or set-group-ID bit is on, and the corresponding
   *        user or group execution bit is also on
   *    S   undefined bit-state (the set-user-ID bit is on and the user
   *        execution bit is off)
   *    t   the 1000 (octal) bit, or sticky bit, is on [see chmod(1)], and
   *        execution is on
   *    T   the 1000 bit is turned on, and execution is off (undefined bit-
   *        state)
   *    e   z/OS external link bit
   *    Final letter may be appended:
   *    +   file has extended security attributes (e.g. ACL)
   *    Note: local listings on MacOSX also use '@'
   *    this is not allowed for here as does not appear to be shown by FTP servers
   *    {@code @}   file has extended attributes
   */
  const RE_LINE = new RegExp("([bcdelfmpSs-])" // file type
      + "(((r|-)(w|-)([xsStTL-]))((r|-)(w|-)([xsStTL-]))((r|-)(w|-)([xsStTL-])))\\+?" // permissions
      + "\\s*" // separator TODO why allow it to be omitted??
      + "(\\d+)" // link count
      + "\\s+" // separator
      + "(?:(\\S+(?:\\s\\S+)*?)\\s+)?" // owner name (optional spaces)
      + "(?:(\\S+(?:\\s\\S+)*)\\s+)?" // group name (optional spaces)
      + "(\\d+(?:,\\s*\\d+)?)" // size or n,m
      + "\\s+" // separator
      /**
       * numeric or standard format date:
       *   yyyy-mm-dd (expecting hh:mm to follow)
       *   MMM [d]d
       *   [d]d MMM
       *   N.B. use non-space for MMM to allow for languages such as German which use
       *   diacritics (e.g. umlaut) in some abbreviations.
       *   Japanese uses numeric day and month with suffixes to distinguish them
       *   [d]dXX [d]dZZ
       */
      + "(" +
      "(?:\\d+[-/]\\d+[-/]\\d+)" + // yyyy-mm-dd
      "|(?:\\S{3}\\s+\\d{1,2})" + // MMM [d]d
      "|(?:\\d{1,2}\\s+\\S{3})" + // [d]d MMM
      "|(?:\\d{1,2}" + JA_MONTH + "\\s+\\d{1,2}" + JA_DAY + ")" +
      ")"
      + "\\s+" // separator
      /**
       * year (for non-recent standard format) - yyyy
       * or time (for numeric or recent standard format) [h]h:mm
       * or Japanese year - yyyyXX
       */
      + "((?:\\d+(?::\\d+)?)|(?:\\d{4}" + JA_YEAR + "))" // (20)
      + "\\s" // separator
      + "(.*)"); // the rest (21)
  /**
   * Returns true if a given line might be a Unix-style listing.
   *
   * - Example: `-rw-r--r--+   1 patrick  staff   1057 Dec 11 14:35 test.txt`
   */
  function testLine(line) {
      return RE_LINE.test(line);
  }
  exports.testLine = testLine;
  /**
   * Parse a single line of a Unix-style directory listing.
   */
  function parseLine(line) {
      const groups = line.match(RE_LINE);
      if (groups === null) {
          return undefined;
      }
      const name = groups[21];
      if (name === "." || name === "..") { // Ignore parent directory links
          return undefined;
      }
      const file = new FileInfo_1.FileInfo(name);
      file.size = parseInt(groups[18], 10);
      file.user = groups[16];
      file.group = groups[17];
      file.hardLinkCount = parseInt(groups[15], 10);
      file.rawModifiedAt = groups[19] + " " + groups[20];
      file.permissions = {
          user: parseMode(groups[4], groups[5], groups[6]),
          group: parseMode(groups[8], groups[9], groups[10]),
          world: parseMode(groups[12], groups[13], groups[14]),
      };
      // Set file type
      switch (groups[1].charAt(0)) {
          case "d":
              file.type = FileInfo_1.FileType.Directory;
              break;
          case "e": // NET-39 => z/OS external link
              file.type = FileInfo_1.FileType.SymbolicLink;
              break;
          case "l":
              file.type = FileInfo_1.FileType.SymbolicLink;
              break;
          case "b":
          case "c":
              file.type = FileInfo_1.FileType.File; // TODO change this if DEVICE_TYPE implemented
              break;
          case "f":
          case "-":
              file.type = FileInfo_1.FileType.File;
              break;
          default:
              // A 'whiteout' file is an ARTIFICIAL entry in any of several types of
              // 'translucent' filesystems, of which a 'union' filesystem is one.
              file.type = FileInfo_1.FileType.Unknown;
      }
      // Separate out the link name for symbolic links
      if (file.isSymbolicLink) {
          const end = name.indexOf(" -> ");
          if (end !== -1) {
              file.name = name.substring(0, end);
              file.link = name.substring(end + 4);
          }
      }
      return file;
  }
  exports.parseLine = parseLine;
  function transformList(files) {
      return files;
  }
  exports.transformList = transformList;
  function parseMode(r, w, x) {
      let value = 0;
      if (r !== "-") {
          value += FileInfo_1.FileInfo.UnixPermission.Read;
      }
      if (w !== "-") {
          value += FileInfo_1.FileInfo.UnixPermission.Write;
      }
      const execToken = x.charAt(0);
      if (execToken !== "-" && execToken.toUpperCase() !== execToken) {
          value += FileInfo_1.FileInfo.UnixPermission.Execute;
      }
      return value;
  }
  
  
  /***/ }),
  
  /***/ 5803:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.downloadTo = exports.uploadFrom = exports.connectForPassiveTransfer = exports.parsePasvResponse = exports.enterPassiveModeIPv4 = exports.parseEpsvResponse = exports.enterPassiveModeIPv6 = void 0;
  const netUtils_1 = __nccwpck_require__(6288);
  const tls_1 = __nccwpck_require__(4016);
  const parseControlResponse_1 = __nccwpck_require__(9948);
  /**
   * Prepare a data socket using passive mode over IPv6.
   */
  async function enterPassiveModeIPv6(ftp) {
      const res = await ftp.request("EPSV");
      const port = parseEpsvResponse(res.message);
      if (!port) {
          throw new Error("Can't parse EPSV response: " + res.message);
      }
      const controlHost = ftp.socket.remoteAddress;
      if (controlHost === undefined) {
          throw new Error("Control socket is disconnected, can't get remote address.");
      }
      await connectForPassiveTransfer(controlHost, port, ftp);
      return res;
  }
  exports.enterPassiveModeIPv6 = enterPassiveModeIPv6;
  /**
   * Parse an EPSV response. Returns only the port as in EPSV the host of the control connection is used.
   */
  function parseEpsvResponse(message) {
      // Get port from EPSV response, e.g. "229 Entering Extended Passive Mode (|||6446|)"
      // Some FTP Servers such as the one on IBM i (OS/400) use ! instead of | in their EPSV response.
      const groups = message.match(/[|!]{3}(.+)[|!]/);
      if (groups === null || groups[1] === undefined) {
          throw new Error(`Can't parse response to 'EPSV': ${message}`);
      }
      const port = parseInt(groups[1], 10);
      if (Number.isNaN(port)) {
          throw new Error(`Can't parse response to 'EPSV', port is not a number: ${message}`);
      }
      return port;
  }
  exports.parseEpsvResponse = parseEpsvResponse;
  /**
   * Prepare a data socket using passive mode over IPv4.
   */
  async function enterPassiveModeIPv4(ftp) {
      const res = await ftp.request("PASV");
      const target = parsePasvResponse(res.message);
      if (!target) {
          throw new Error("Can't parse PASV response: " + res.message);
      }
      // If the host in the PASV response has a local address while the control connection hasn't,
      // we assume a NAT issue and use the IP of the control connection as the target for the data connection.
      // We can't always perform this replacement because it's possible (although unlikely) that the FTP server
      // indeed uses a different host for data connections.
      const controlHost = ftp.socket.remoteAddress;
      if (netUtils_1.ipIsPrivateV4Address(target.host) && controlHost && !netUtils_1.ipIsPrivateV4Address(controlHost)) {
          target.host = controlHost;
      }
      await connectForPassiveTransfer(target.host, target.port, ftp);
      return res;
  }
  exports.enterPassiveModeIPv4 = enterPassiveModeIPv4;
  /**
   * Parse a PASV response.
   */
  function parsePasvResponse(message) {
      // Get host and port from PASV response, e.g. "227 Entering Passive Mode (192,168,1,100,10,229)"
      const groups = message.match(/([-\d]+,[-\d]+,[-\d]+,[-\d]+),([-\d]+),([-\d]+)/);
      if (groups === null || groups.length !== 4) {
          throw new Error(`Can't parse response to 'PASV': ${message}`);
      }
      return {
          host: groups[1].replace(/,/g, "."),
          port: (parseInt(groups[2], 10) & 255) * 256 + (parseInt(groups[3], 10) & 255)
      };
  }
  exports.parsePasvResponse = parsePasvResponse;
  function connectForPassiveTransfer(host, port, ftp) {
      return new Promise((resolve, reject) => {
          const handleConnErr = function (err) {
              err.message = "Can't open data connection in passive mode: " + err.message;
              reject(err);
          };
          let socket = ftp._newSocket();
          socket.on("error", handleConnErr);
          socket.connect({ port, host, family: ftp.ipFamily }, () => {
              if (ftp.socket instanceof tls_1.TLSSocket) {
                  socket = tls_1.connect(Object.assign({}, ftp.tlsOptions, {
                      socket,
                      // Reuse the TLS session negotiated earlier when the control connection
                      // was upgraded. Servers expect this because it provides additional
                      // security: If a completely new session would be negotiated, a hacker
                      // could guess the port and connect to the new data connection before we do
                      // by just starting his/her own TLS session.
                      session: ftp.socket.getSession()
                  }));
                  // It's the responsibility of the transfer task to wait until the
                  // TLS socket issued the event 'secureConnect'. We can't do this
                  // here because some servers will start upgrading after the
                  // specific transfer request has been made. List and download don't
                  // have to wait for this event because the server sends whenever it
                  // is ready. But for upload this has to be taken into account,
                  // see the details in the upload() function below.
              }
              // Let the FTPContext listen to errors from now on, remove local handler.
              socket.removeListener("error", handleConnErr);
              ftp.dataSocket = socket;
              resolve();
          });
      });
  }
  exports.connectForPassiveTransfer = connectForPassiveTransfer;
  /**
   * Helps resolving/rejecting transfers.
   *
   * This is used internally for all FTP transfers. For example when downloading, the server might confirm
   * with "226 Transfer complete" when in fact the download on the data connection has not finished
   * yet. With all transfers we make sure that a) the result arrived and b) has been confirmed by
   * e.g. the control connection. We just don't know in which order this will happen.
   */
  class TransferResolver {
      /**
       * Instantiate a TransferResolver
       */
      constructor(ftp, progress) {
          this.ftp = ftp;
          this.progress = progress;
          this.response = undefined;
          this.dataTransferDone = false;
      }
      /**
       * Mark the beginning of a transfer.
       *
       * @param name - Name of the transfer, usually the filename.
       * @param type - Type of transfer, usually "upload" or "download".
       */
      onDataStart(name, type) {
          // Let the data socket be in charge of tracking timeouts during transfer.
          // The control socket sits idle during this time anyway and might provoke
          // a timeout unnecessarily. The control connection will take care
          // of timeouts again once data transfer is complete or failed.
          if (this.ftp.dataSocket === undefined) {
              throw new Error("Data transfer should start but there is no data connection.");
          }
          this.ftp.socket.setTimeout(0);
          this.ftp.dataSocket.setTimeout(this.ftp.timeout);
          this.progress.start(this.ftp.dataSocket, name, type);
      }
      /**
       * The data connection has finished the transfer.
       */
      onDataDone(task) {
          this.progress.updateAndStop();
          // Hand-over timeout tracking back to the control connection. It's possible that
          // we don't receive the response over the control connection that the transfer is
          // done. In this case, we want to correctly associate the resulting timeout with
          // the control connection.
          this.ftp.socket.setTimeout(this.ftp.timeout);
          if (this.ftp.dataSocket) {
              this.ftp.dataSocket.setTimeout(0);
          }
          this.dataTransferDone = true;
          this.tryResolve(task);
      }
      /**
       * The control connection reports the transfer as finished.
       */
      onControlDone(task, response) {
          this.response = response;
          this.tryResolve(task);
      }
      /**
       * An error has been reported and the task should be rejected.
       */
      onError(task, err) {
          this.progress.updateAndStop();
          this.ftp.socket.setTimeout(this.ftp.timeout);
          this.ftp.dataSocket = undefined;
          task.reject(err);
      }
      /**
       * Control connection sent an unexpected request requiring a response from our part. We
       * can't provide that (because unknown) and have to close the contrext with an error because
       * the FTP server is now caught up in a state we can't resolve.
       */
      onUnexpectedRequest(response) {
          const err = new Error(`Unexpected FTP response is requesting an answer: ${response.message}`);
          this.ftp.closeWithError(err);
      }
      tryResolve(task) {
          // To resolve, we need both control and data connection to report that the transfer is done.
          const canResolve = this.dataTransferDone && this.response !== undefined;
          if (canResolve) {
              this.ftp.dataSocket = undefined;
              task.resolve(this.response);
          }
      }
  }
  function uploadFrom(source, config) {
      const resolver = new TransferResolver(config.ftp, config.tracker);
      const fullCommand = `${config.command} ${config.remotePath}`;
      return config.ftp.handle(fullCommand, (res, task) => {
          if (res instanceof Error) {
              resolver.onError(task, res);
          }
          else if (res.code === 150 || res.code === 125) { // Ready to upload
              const dataSocket = config.ftp.dataSocket;
              if (!dataSocket) {
                  resolver.onError(task, new Error("Upload should begin but no data connection is available."));
                  return;
              }
              // If we are using TLS, we have to wait until the dataSocket issued
              // 'secureConnect'. If this hasn't happened yet, getCipher() returns undefined.
              const canUpload = "getCipher" in dataSocket ? dataSocket.getCipher() !== undefined : true;
              onConditionOrEvent(canUpload, dataSocket, "secureConnect", () => {
                  config.ftp.log(`Uploading to ${netUtils_1.describeAddress(dataSocket)} (${netUtils_1.describeTLS(dataSocket)})`);
                  resolver.onDataStart(config.remotePath, config.type);
                  source.pipe(dataSocket).once("finish", () => {
                      dataSocket.destroy(); // Explicitly close/destroy the socket to signal the end.
                      resolver.onDataDone(task);
                  });
              });
          }
          else if (parseControlResponse_1.positiveCompletion(res.code)) { // Transfer complete
              resolver.onControlDone(task, res);
          }
          else if (parseControlResponse_1.positiveIntermediate(res.code)) {
              resolver.onUnexpectedRequest(res);
          }
          // Ignore all other positive preliminary response codes (< 200)
      });
  }
  exports.uploadFrom = uploadFrom;
  function downloadTo(destination, config) {
      if (!config.ftp.dataSocket) {
          throw new Error("Download will be initiated but no data connection is available.");
      }
      // It's possible that data transmission begins before the control socket
      // receives the announcement. Start listening for data immediately.
      config.ftp.dataSocket.pipe(destination);
      const resolver = new TransferResolver(config.ftp, config.tracker);
      return config.ftp.handle(config.command, (res, task) => {
          if (res instanceof Error) {
              resolver.onError(task, res);
          }
          else if (res.code === 150 || res.code === 125) { // Ready to download
              const dataSocket = config.ftp.dataSocket;
              if (!dataSocket) {
                  resolver.onError(task, new Error("Download should begin but no data connection is available."));
                  return;
              }
              config.ftp.log(`Downloading from ${netUtils_1.describeAddress(dataSocket)} (${netUtils_1.describeTLS(dataSocket)})`);
              resolver.onDataStart(config.remotePath, config.type);
              onConditionOrEvent(isWritableFinished(destination), destination, "finish", () => resolver.onDataDone(task));
          }
          else if (res.code === 350) { // Restarting at startAt.
              config.ftp.send("RETR " + config.remotePath);
          }
          else if (parseControlResponse_1.positiveCompletion(res.code)) { // Transfer complete
              resolver.onControlDone(task, res);
          }
          else if (parseControlResponse_1.positiveIntermediate(res.code)) {
              resolver.onUnexpectedRequest(res);
          }
          // Ignore all other positive preliminary response codes (< 200)
      });
  }
  exports.downloadTo = downloadTo;
  /**
   * Calls a function immediately if a condition is met or subscribes to an event and calls
   * it once the event is emitted.
   *
   * @param condition  The condition to test.
   * @param emitter  The emitter to use if the condition is not met.
   * @param eventName  The event to subscribe to if the condition is not met.
   * @param action  The function to call.
   */
  function onConditionOrEvent(condition, emitter, eventName, action) {
      if (condition === true) {
          action();
      }
      else {
          emitter.once(eventName, () => action());
      }
  }
  /**
   * Detect whether a writable stream is finished, supporting Node 8.
   * From https://github.com/nodejs/node/blob/3e2a3007107b7a100794f4e4adbde19263fc7464/lib/internal/streams/end-of-stream.js#L28-L33
   */
  function isWritableFinished(stream) {
      if (stream.writableFinished)
          return true;
      const wState = stream._writableState;
      if (!wState || wState.errored)
          return false;
      return wState.finished || (wState.ended && wState.length === 0);
  }
  
  
  /***/ }),
  
  /***/ 3717:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  var concatMap = __nccwpck_require__(6891);
  var balanced = __nccwpck_require__(9417);
  
  module.exports = expandTop;
  
  var escSlash = '\0SLASH'+Math.random()+'\0';
  var escOpen = '\0OPEN'+Math.random()+'\0';
  var escClose = '\0CLOSE'+Math.random()+'\0';
  var escComma = '\0COMMA'+Math.random()+'\0';
  var escPeriod = '\0PERIOD'+Math.random()+'\0';
  
  function numeric(str) {
    return parseInt(str, 10) == str
      ? parseInt(str, 10)
      : str.charCodeAt(0);
  }
  
  function escapeBraces(str) {
    return str.split('\\\\').join(escSlash)
              .split('\\{').join(escOpen)
              .split('\\}').join(escClose)
              .split('\\,').join(escComma)
              .split('\\.').join(escPeriod);
  }
  
  function unescapeBraces(str) {
    return str.split(escSlash).join('\\')
              .split(escOpen).join('{')
              .split(escClose).join('}')
              .split(escComma).join(',')
              .split(escPeriod).join('.');
  }
  
  
  // Basically just str.split(","), but handling cases
  // where we have nested braced sections, which should be
  // treated as individual members, like {a,{b,c},d}
  function parseCommaParts(str) {
    if (!str)
      return [''];
  
    var parts = [];
    var m = balanced('{', '}', str);
  
    if (!m)
      return str.split(',');
  
    var pre = m.pre;
    var body = m.body;
    var post = m.post;
    var p = pre.split(',');
  
    p[p.length-1] += '{' + body + '}';
    var postParts = parseCommaParts(post);
    if (post.length) {
      p[p.length-1] += postParts.shift();
      p.push.apply(p, postParts);
    }
  
    parts.push.apply(parts, p);
  
    return parts;
  }
  
  function expandTop(str) {
    if (!str)
      return [];
  
    // I don't know why Bash 4.3 does this, but it does.
    // Anything starting with {} will have the first two bytes preserved
    // but *only* at the top level, so {},a}b will not expand to anything,
    // but a{},b}c will be expanded to [a}c,abc].
    // One could argue that this is a bug in Bash, but since the goal of
    // this module is to match Bash's rules, we escape a leading {}
    if (str.substr(0, 2) === '{}') {
      str = '\\{\\}' + str.substr(2);
    }
  
    return expand(escapeBraces(str), true).map(unescapeBraces);
  }
  
  function identity(e) {
    return e;
  }
  
  function embrace(str) {
    return '{' + str + '}';
  }
  function isPadded(el) {
    return /^-?0\d/.test(el);
  }
  
  function lte(i, y) {
    return i <= y;
  }
  function gte(i, y) {
    return i >= y;
  }
  
  function expand(str, isTop) {
    var expansions = [];
  
    var m = balanced('{', '}', str);
    if (!m || /\$$/.test(m.pre)) return [str];
  
    var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
    var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
    var isSequence = isNumericSequence || isAlphaSequence;
    var isOptions = m.body.indexOf(',') >= 0;
    if (!isSequence && !isOptions) {
      // {a},b}
      if (m.post.match(/,.*\}/)) {
        str = m.pre + '{' + m.body + escClose + m.post;
        return expand(str);
      }
      return [str];
    }
  
    var n;
    if (isSequence) {
      n = m.body.split(/\.\./);
    } else {
      n = parseCommaParts(m.body);
      if (n.length === 1) {
        // x{{a,b}}y ==> x{a}y x{b}y
        n = expand(n[0], false).map(embrace);
        if (n.length === 1) {
          var post = m.post.length
            ? expand(m.post, false)
            : [''];
          return post.map(function(p) {
            return m.pre + n[0] + p;
          });
        }
      }
    }
  
    // at this point, n is the parts, and we know it's not a comma set
    // with a single entry.
  
    // no need to expand pre, since it is guaranteed to be free of brace-sets
    var pre = m.pre;
    var post = m.post.length
      ? expand(m.post, false)
      : [''];
  
    var N;
  
    if (isSequence) {
      var x = numeric(n[0]);
      var y = numeric(n[1]);
      var width = Math.max(n[0].length, n[1].length)
      var incr = n.length == 3
        ? Math.abs(numeric(n[2]))
        : 1;
      var test = lte;
      var reverse = y < x;
      if (reverse) {
        incr *= -1;
        test = gte;
      }
      var pad = n.some(isPadded);
  
      N = [];
  
      for (var i = x; test(i, y); i += incr) {
        var c;
        if (isAlphaSequence) {
          c = String.fromCharCode(i);
          if (c === '\\')
            c = '';
        } else {
          c = String(i);
          if (pad) {
            var need = width - c.length;
            if (need > 0) {
              var z = new Array(need + 1).join('0');
              if (i < 0)
                c = '-' + z + c.slice(1);
              else
                c = z + c;
            }
          }
        }
        N.push(c);
      }
    } else {
      N = concatMap(n, function(el) { return expand(el, false) });
    }
  
    for (var j = 0; j < N.length; j++) {
      for (var k = 0; k < post.length; k++) {
        var expansion = pre + N[j] + post[k];
        if (!isTop || isSequence || expansion)
          expansions.push(expansion);
      }
    }
  
    return expansions;
  }
  
  
  
  /***/ }),
  
  /***/ 6891:
  /***/ ((module) => {
  
  module.exports = function (xs, fn) {
      var res = [];
      for (var i = 0; i < xs.length; i++) {
          var x = fn(xs[i], i);
          if (isArray(x)) res.push.apply(res, x);
          else res.push(x);
      }
      return res;
  };
  
  var isArray = Array.isArray || function (xs) {
      return Object.prototype.toString.call(xs) === '[object Array]';
  };
  
  
  /***/ }),
  
  /***/ 7117:
  /***/ ((module) => {
  
  module.exports = function (glob, opts) {
    if (typeof glob !== 'string') {
      throw new TypeError('Expected a string');
    }
  
    var str = String(glob);
  
    // The regexp we are building, as a string.
    var reStr = "";
  
    // Whether we are matching so called "extended" globs (like bash) and should
    // support single character matching, matching ranges of characters, group
    // matching, etc.
    var extended = opts ? !!opts.extended : false;
  
    // When globstar is _false_ (default), '/foo/*' is translated a regexp like
    // '^\/foo\/.*$' which will match any string beginning with '/foo/'
    // When globstar is _true_, '/foo/*' is translated to regexp like
    // '^\/foo\/[^/]*$' which will match any string beginning with '/foo/' BUT
    // which does not have a '/' to the right of it.
    // E.g. with '/foo/*' these will match: '/foo/bar', '/foo/bar.txt' but
    // these will not '/foo/bar/baz', '/foo/bar/baz.txt'
    // Lastely, when globstar is _true_, '/foo/**' is equivelant to '/foo/*' when
    // globstar is _false_
    var globstar = opts ? !!opts.globstar : false;
  
    // If we are doing extended matching, this boolean is true when we are inside
    // a group (eg {*.html,*.js}), and false otherwise.
    var inGroup = false;
  
    // RegExp flags (eg "i" ) to pass in to RegExp constructor.
    var flags = opts && typeof( opts.flags ) === "string" ? opts.flags : "";
  
    var c;
    for (var i = 0, len = str.length; i < len; i++) {
      c = str[i];
  
      switch (c) {
      case "/":
      case "$":
      case "^":
      case "+":
      case ".":
      case "(":
      case ")":
      case "=":
      case "!":
      case "|":
        reStr += "\\" + c;
        break;
  
      case "?":
        if (extended) {
          reStr += ".";
  	    break;
        }
  
      case "[":
      case "]":
        if (extended) {
          reStr += c;
  	    break;
        }
  
      case "{":
        if (extended) {
          inGroup = true;
  	    reStr += "(";
  	    break;
        }
  
      case "}":
        if (extended) {
          inGroup = false;
  	    reStr += ")";
  	    break;
        }
  
      case ",":
        if (inGroup) {
          reStr += "|";
  	    break;
        }
        reStr += "\\" + c;
        break;
  
      case "*":
        // Move over all consecutive "*"'s.
        // Also store the previous and next characters
        var prevChar = str[i - 1];
        var starCount = 1;
        while(str[i + 1] === "*") {
          starCount++;
          i++;
        }
        var nextChar = str[i + 1];
  
        if (!globstar) {
          // globstar is disabled, so treat any number of "*" as one
          reStr += ".*";
        } else {
          // globstar is enabled, so determine if this is a globstar segment
          var isGlobstar = starCount > 1                      // multiple "*"'s
            && (prevChar === "/" || prevChar === undefined)   // from the start of the segment
            && (nextChar === "/" || nextChar === undefined)   // to the end of the segment
  
          if (isGlobstar) {
            // it's a globstar, so match zero or more path segments
            reStr += "((?:[^/]*(?:\/|$))*)";
            i++; // move over the "/"
          } else {
            // it's not a globstar, so only match one path segment
            reStr += "([^/]*)";
          }
        }
        break;
  
      default:
        reStr += c;
      }
    }
  
    // When regexp 'g' flag is specified don't
    // constrain the regular expression with ^ & $
    if (!flags || !~flags.indexOf('g')) {
      reStr = "^" + reStr + "$";
    }
  
    return new RegExp(reStr, flags);
  };
  
  
  /***/ }),
  
  /***/ 3973:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  module.exports = minimatch
  minimatch.Minimatch = Minimatch
  
  var path = { sep: '/' }
  try {
    path = __nccwpck_require__(5622)
  } catch (er) {}
  
  var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {}
  var expand = __nccwpck_require__(3717)
  
  var plTypes = {
    '!': { open: '(?:(?!(?:', close: '))[^/]*?)'},
    '?': { open: '(?:', close: ')?' },
    '+': { open: '(?:', close: ')+' },
    '*': { open: '(?:', close: ')*' },
    '@': { open: '(?:', close: ')' }
  }
  
  // any single thing other than /
  // don't need to escape / when using new RegExp()
  var qmark = '[^/]'
  
  // * => any number of characters
  var star = qmark + '*?'
  
  // ** when dots are allowed.  Anything goes, except .. and .
  // not (^ or / followed by one or two dots followed by $ or /),
  // followed by anything, any number of times.
  var twoStarDot = '(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?'
  
  // not a ^ or / followed by a dot,
  // followed by anything, any number of times.
  var twoStarNoDot = '(?:(?!(?:\\\/|^)\\.).)*?'
  
  // characters that need to be escaped in RegExp.
  var reSpecials = charSet('().*{}+?[]^$\\!')
  
  // "abc" -> { a:true, b:true, c:true }
  function charSet (s) {
    return s.split('').reduce(function (set, c) {
      set[c] = true
      return set
    }, {})
  }
  
  // normalizes slashes.
  var slashSplit = /\/+/
  
  minimatch.filter = filter
  function filter (pattern, options) {
    options = options || {}
    return function (p, i, list) {
      return minimatch(p, pattern, options)
    }
  }
  
  function ext (a, b) {
    a = a || {}
    b = b || {}
    var t = {}
    Object.keys(b).forEach(function (k) {
      t[k] = b[k]
    })
    Object.keys(a).forEach(function (k) {
      t[k] = a[k]
    })
    return t
  }
  
  minimatch.defaults = function (def) {
    if (!def || !Object.keys(def).length) return minimatch
  
    var orig = minimatch
  
    var m = function minimatch (p, pattern, options) {
      return orig.minimatch(p, pattern, ext(def, options))
    }
  
    m.Minimatch = function Minimatch (pattern, options) {
      return new orig.Minimatch(pattern, ext(def, options))
    }
  
    return m
  }
  
  Minimatch.defaults = function (def) {
    if (!def || !Object.keys(def).length) return Minimatch
    return minimatch.defaults(def).Minimatch
  }
  
  function minimatch (p, pattern, options) {
    if (typeof pattern !== 'string') {
      throw new TypeError('glob pattern string required')
    }
  
    if (!options) options = {}
  
    // shortcut: comments match nothing.
    if (!options.nocomment && pattern.charAt(0) === '#') {
      return false
    }
  
    // "" only matches ""
    if (pattern.trim() === '') return p === ''
  
    return new Minimatch(pattern, options).match(p)
  }
  
  function Minimatch (pattern, options) {
    if (!(this instanceof Minimatch)) {
      return new Minimatch(pattern, options)
    }
  
    if (typeof pattern !== 'string') {
      throw new TypeError('glob pattern string required')
    }
  
    if (!options) options = {}
    pattern = pattern.trim()
  
    // windows support: need to use /, not \
    if (path.sep !== '/') {
      pattern = pattern.split(path.sep).join('/')
    }
  
    this.options = options
    this.set = []
    this.pattern = pattern
    this.regexp = null
    this.negate = false
    this.comment = false
    this.empty = false
  
    // make the set of regexps etc.
    this.make()
  }
  
  Minimatch.prototype.debug = function () {}
  
  Minimatch.prototype.make = make
  function make () {
    // don't do it more than once.
    if (this._made) return
  
    var pattern = this.pattern
    var options = this.options
  
    // empty patterns and comments match nothing.
    if (!options.nocomment && pattern.charAt(0) === '#') {
      this.comment = true
      return
    }
    if (!pattern) {
      this.empty = true
      return
    }
  
    // step 1: figure out negation, etc.
    this.parseNegate()
  
    // step 2: expand braces
    var set = this.globSet = this.braceExpand()
  
    if (options.debug) this.debug = console.error
  
    this.debug(this.pattern, set)
  
    // step 3: now we have a set, so turn each one into a series of path-portion
    // matching patterns.
    // These will be regexps, except in the case of "**", which is
    // set to the GLOBSTAR object for globstar behavior,
    // and will not contain any / characters
    set = this.globParts = set.map(function (s) {
      return s.split(slashSplit)
    })
  
    this.debug(this.pattern, set)
  
    // glob --> regexps
    set = set.map(function (s, si, set) {
      return s.map(this.parse, this)
    }, this)
  
    this.debug(this.pattern, set)
  
    // filter out everything that didn't compile properly.
    set = set.filter(function (s) {
      return s.indexOf(false) === -1
    })
  
    this.debug(this.pattern, set)
  
    this.set = set
  }
  
  Minimatch.prototype.parseNegate = parseNegate
  function parseNegate () {
    var pattern = this.pattern
    var negate = false
    var options = this.options
    var negateOffset = 0
  
    if (options.nonegate) return
  
    for (var i = 0, l = pattern.length
      ; i < l && pattern.charAt(i) === '!'
      ; i++) {
      negate = !negate
      negateOffset++
    }
  
    if (negateOffset) this.pattern = pattern.substr(negateOffset)
    this.negate = negate
  }
  
  // Brace expansion:
  // a{b,c}d -> abd acd
  // a{b,}c -> abc ac
  // a{0..3}d -> a0d a1d a2d a3d
  // a{b,c{d,e}f}g -> abg acdfg acefg
  // a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg
  //
  // Invalid sets are not expanded.
  // a{2..}b -> a{2..}b
  // a{b}c -> a{b}c
  minimatch.braceExpand = function (pattern, options) {
    return braceExpand(pattern, options)
  }
  
  Minimatch.prototype.braceExpand = braceExpand
  
  function braceExpand (pattern, options) {
    if (!options) {
      if (this instanceof Minimatch) {
        options = this.options
      } else {
        options = {}
      }
    }
  
    pattern = typeof pattern === 'undefined'
      ? this.pattern : pattern
  
    if (typeof pattern === 'undefined') {
      throw new TypeError('undefined pattern')
    }
  
    if (options.nobrace ||
      !pattern.match(/\{.*\}/)) {
      // shortcut. no need to expand.
      return [pattern]
    }
  
    return expand(pattern)
  }
  
  // parse a component of the expanded set.
  // At this point, no pattern may contain "/" in it
  // so we're going to return a 2d array, where each entry is the full
  // pattern, split on '/', and then turned into a regular expression.
  // A regexp is made at the end which joins each array with an
  // escaped /, and another full one which joins each regexp with |.
  //
  // Following the lead of Bash 4.1, note that "**" only has special meaning
  // when it is the *only* thing in a path portion.  Otherwise, any series
  // of * is equivalent to a single *.  Globstar behavior is enabled by
  // default, and can be disabled by setting options.noglobstar.
  Minimatch.prototype.parse = parse
  var SUBPARSE = {}
  function parse (pattern, isSub) {
    if (pattern.length > 1024 * 64) {
      throw new TypeError('pattern is too long')
    }
  
    var options = this.options
  
    // shortcuts
    if (!options.noglobstar && pattern === '**') return GLOBSTAR
    if (pattern === '') return ''
  
    var re = ''
    var hasMagic = !!options.nocase
    var escaping = false
    // ? => one single character
    var patternListStack = []
    var negativeLists = []
    var stateChar
    var inClass = false
    var reClassStart = -1
    var classStart = -1
    // . and .. never match anything that doesn't start with .,
    // even when options.dot is set.
    var patternStart = pattern.charAt(0) === '.' ? '' // anything
    // not (start or / followed by . or .. followed by / or end)
    : options.dot ? '(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))'
    : '(?!\\.)'
    var self = this
  
    function clearStateChar () {
      if (stateChar) {
        // we had some state-tracking character
        // that wasn't consumed by this pass.
        switch (stateChar) {
          case '*':
            re += star
            hasMagic = true
          break
          case '?':
            re += qmark
            hasMagic = true
          break
          default:
            re += '\\' + stateChar
          break
        }
        self.debug('clearStateChar %j %j', stateChar, re)
        stateChar = false
      }
    }
  
    for (var i = 0, len = pattern.length, c
      ; (i < len) && (c = pattern.charAt(i))
      ; i++) {
      this.debug('%s\t%s %s %j', pattern, i, re, c)
  
      // skip over any that are escaped.
      if (escaping && reSpecials[c]) {
        re += '\\' + c
        escaping = false
        continue
      }
  
      switch (c) {
        case '/':
          // completely not allowed, even escaped.
          // Should already be path-split by now.
          return false
  
        case '\\':
          clearStateChar()
          escaping = true
        continue
  
        // the various stateChar values
        // for the "extglob" stuff.
        case '?':
        case '*':
        case '+':
        case '@':
        case '!':
          this.debug('%s\t%s %s %j <-- stateChar', pattern, i, re, c)
  
          // all of those are literals inside a class, except that
          // the glob [!a] means [^a] in regexp
          if (inClass) {
            this.debug('  in class')
            if (c === '!' && i === classStart + 1) c = '^'
            re += c
            continue
          }
  
          // if we already have a stateChar, then it means
          // that there was something like ** or +? in there.
          // Handle the stateChar, then proceed with this one.
          self.debug('call clearStateChar %j', stateChar)
          clearStateChar()
          stateChar = c
          // if extglob is disabled, then +(asdf|foo) isn't a thing.
          // just clear the statechar *now*, rather than even diving into
          // the patternList stuff.
          if (options.noext) clearStateChar()
        continue
  
        case '(':
          if (inClass) {
            re += '('
            continue
          }
  
          if (!stateChar) {
            re += '\\('
            continue
          }
  
          patternListStack.push({
            type: stateChar,
            start: i - 1,
            reStart: re.length,
            open: plTypes[stateChar].open,
            close: plTypes[stateChar].close
          })
          // negation is (?:(?!js)[^/]*)
          re += stateChar === '!' ? '(?:(?!(?:' : '(?:'
          this.debug('plType %j %j', stateChar, re)
          stateChar = false
        continue
  
        case ')':
          if (inClass || !patternListStack.length) {
            re += '\\)'
            continue
          }
  
          clearStateChar()
          hasMagic = true
          var pl = patternListStack.pop()
          // negation is (?:(?!js)[^/]*)
          // The others are (?:<pattern>)<type>
          re += pl.close
          if (pl.type === '!') {
            negativeLists.push(pl)
          }
          pl.reEnd = re.length
        continue
  
        case '|':
          if (inClass || !patternListStack.length || escaping) {
            re += '\\|'
            escaping = false
            continue
          }
  
          clearStateChar()
          re += '|'
        continue
  
        // these are mostly the same in regexp and glob
        case '[':
          // swallow any state-tracking char before the [
          clearStateChar()
  
          if (inClass) {
            re += '\\' + c
            continue
          }
  
          inClass = true
          classStart = i
          reClassStart = re.length
          re += c
        continue
  
        case ']':
          //  a right bracket shall lose its special
          //  meaning and represent itself in
          //  a bracket expression if it occurs
          //  first in the list.  -- POSIX.2 2.8.3.2
          if (i === classStart + 1 || !inClass) {
            re += '\\' + c
            escaping = false
            continue
          }
  
          // handle the case where we left a class open.
          // "[z-a]" is valid, equivalent to "\[z-a\]"
          if (inClass) {
            // split where the last [ was, make sure we don't have
            // an invalid re. if so, re-walk the contents of the
            // would-be class to re-translate any characters that
            // were passed through as-is
            // TODO: It would probably be faster to determine this
            // without a try/catch and a new RegExp, but it's tricky
            // to do safely.  For now, this is safe and works.
            var cs = pattern.substring(classStart + 1, i)
            try {
              RegExp('[' + cs + ']')
            } catch (er) {
              // not a valid class!
              var sp = this.parse(cs, SUBPARSE)
              re = re.substr(0, reClassStart) + '\\[' + sp[0] + '\\]'
              hasMagic = hasMagic || sp[1]
              inClass = false
              continue
            }
          }
  
          // finish up the class.
          hasMagic = true
          inClass = false
          re += c
        continue
  
        default:
          // swallow any state char that wasn't consumed
          clearStateChar()
  
          if (escaping) {
            // no need
            escaping = false
          } else if (reSpecials[c]
            && !(c === '^' && inClass)) {
            re += '\\'
          }
  
          re += c
  
      } // switch
    } // for
  
    // handle the case where we left a class open.
    // "[abc" is valid, equivalent to "\[abc"
    if (inClass) {
      // split where the last [ was, and escape it
      // this is a huge pita.  We now have to re-walk
      // the contents of the would-be class to re-translate
      // any characters that were passed through as-is
      cs = pattern.substr(classStart + 1)
      sp = this.parse(cs, SUBPARSE)
      re = re.substr(0, reClassStart) + '\\[' + sp[0]
      hasMagic = hasMagic || sp[1]
    }
  
    // handle the case where we had a +( thing at the *end*
    // of the pattern.
    // each pattern list stack adds 3 chars, and we need to go through
    // and escape any | chars that were passed through as-is for the regexp.
    // Go through and escape them, taking care not to double-escape any
    // | chars that were already escaped.
    for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
      var tail = re.slice(pl.reStart + pl.open.length)
      this.debug('setting tail', re, pl)
      // maybe some even number of \, then maybe 1 \, followed by a |
      tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function (_, $1, $2) {
        if (!$2) {
          // the | isn't already escaped, so escape it.
          $2 = '\\'
        }
  
        // need to escape all those slashes *again*, without escaping the
        // one that we need for escaping the | character.  As it works out,
        // escaping an even number of slashes can be done by simply repeating
        // it exactly after itself.  That's why this trick works.
        //
        // I am sorry that you have to see this.
        return $1 + $1 + $2 + '|'
      })
  
      this.debug('tail=%j\n   %s', tail, tail, pl, re)
      var t = pl.type === '*' ? star
        : pl.type === '?' ? qmark
        : '\\' + pl.type
  
      hasMagic = true
      re = re.slice(0, pl.reStart) + t + '\\(' + tail
    }
  
    // handle trailing things that only matter at the very end.
    clearStateChar()
    if (escaping) {
      // trailing \\
      re += '\\\\'
    }
  
    // only need to apply the nodot start if the re starts with
    // something that could conceivably capture a dot
    var addPatternStart = false
    switch (re.charAt(0)) {
      case '.':
      case '[':
      case '(': addPatternStart = true
    }
  
    // Hack to work around lack of negative lookbehind in JS
    // A pattern like: *.!(x).!(y|z) needs to ensure that a name
    // like 'a.xyz.yz' doesn't match.  So, the first negative
    // lookahead, has to look ALL the way ahead, to the end of
    // the pattern.
    for (var n = negativeLists.length - 1; n > -1; n--) {
      var nl = negativeLists[n]
  
      var nlBefore = re.slice(0, nl.reStart)
      var nlFirst = re.slice(nl.reStart, nl.reEnd - 8)
      var nlLast = re.slice(nl.reEnd - 8, nl.reEnd)
      var nlAfter = re.slice(nl.reEnd)
  
      nlLast += nlAfter
  
      // Handle nested stuff like *(*.js|!(*.json)), where open parens
      // mean that we should *not* include the ) in the bit that is considered
      // "after" the negated section.
      var openParensBefore = nlBefore.split('(').length - 1
      var cleanAfter = nlAfter
      for (i = 0; i < openParensBefore; i++) {
        cleanAfter = cleanAfter.replace(/\)[+*?]?/, '')
      }
      nlAfter = cleanAfter
  
      var dollar = ''
      if (nlAfter === '' && isSub !== SUBPARSE) {
        dollar = '$'
      }
      var newRe = nlBefore + nlFirst + nlAfter + dollar + nlLast
      re = newRe
    }
  
    // if the re is not "" at this point, then we need to make sure
    // it doesn't match against an empty path part.
    // Otherwise a/* will match a/, which it should not.
    if (re !== '' && hasMagic) {
      re = '(?=.)' + re
    }
  
    if (addPatternStart) {
      re = patternStart + re
    }
  
    // parsing just a piece of a larger pattern.
    if (isSub === SUBPARSE) {
      return [re, hasMagic]
    }
  
    // skip the regexp for non-magical patterns
    // unescape anything in it, though, so that it'll be
    // an exact match against a file etc.
    if (!hasMagic) {
      return globUnescape(pattern)
    }
  
    var flags = options.nocase ? 'i' : ''
    try {
      var regExp = new RegExp('^' + re + '$', flags)
    } catch (er) {
      // If it was an invalid regular expression, then it can't match
      // anything.  This trick looks for a character after the end of
      // the string, which is of course impossible, except in multi-line
      // mode, but it's not a /m regex.
      return new RegExp('$.')
    }
  
    regExp._glob = pattern
    regExp._src = re
  
    return regExp
  }
  
  minimatch.makeRe = function (pattern, options) {
    return new Minimatch(pattern, options || {}).makeRe()
  }
  
  Minimatch.prototype.makeRe = makeRe
  function makeRe () {
    if (this.regexp || this.regexp === false) return this.regexp
  
    // at this point, this.set is a 2d array of partial
    // pattern strings, or "**".
    //
    // It's better to use .match().  This function shouldn't
    // be used, really, but it's pretty convenient sometimes,
    // when you just want to work with a regex.
    var set = this.set
  
    if (!set.length) {
      this.regexp = false
      return this.regexp
    }
    var options = this.options
  
    var twoStar = options.noglobstar ? star
      : options.dot ? twoStarDot
      : twoStarNoDot
    var flags = options.nocase ? 'i' : ''
  
    var re = set.map(function (pattern) {
      return pattern.map(function (p) {
        return (p === GLOBSTAR) ? twoStar
        : (typeof p === 'string') ? regExpEscape(p)
        : p._src
      }).join('\\\/')
    }).join('|')
  
    // must match entire pattern
    // ending in a * or ** will make it less strict.
    re = '^(?:' + re + ')$'
  
    // can match anything, as long as it's not this.
    if (this.negate) re = '^(?!' + re + ').*$'
  
    try {
      this.regexp = new RegExp(re, flags)
    } catch (ex) {
      this.regexp = false
    }
    return this.regexp
  }
  
  minimatch.match = function (list, pattern, options) {
    options = options || {}
    var mm = new Minimatch(pattern, options)
    list = list.filter(function (f) {
      return mm.match(f)
    })
    if (mm.options.nonull && !list.length) {
      list.push(pattern)
    }
    return list
  }
  
  Minimatch.prototype.match = match
  function match (f, partial) {
    this.debug('match', f, this.pattern)
    // short-circuit in the case of busted things.
    // comments, etc.
    if (this.comment) return false
    if (this.empty) return f === ''
  
    if (f === '/' && partial) return true
  
    var options = this.options
  
    // windows: need to use /, not \
    if (path.sep !== '/') {
      f = f.split(path.sep).join('/')
    }
  
    // treat the test path as a set of pathparts.
    f = f.split(slashSplit)
    this.debug(this.pattern, 'split', f)
  
    // just ONE of the pattern sets in this.set needs to match
    // in order for it to be valid.  If negating, then just one
    // match means that we have failed.
    // Either way, return on the first hit.
  
    var set = this.set
    this.debug(this.pattern, 'set', set)
  
    // Find the basename of the path by looking for the last non-empty segment
    var filename
    var i
    for (i = f.length - 1; i >= 0; i--) {
      filename = f[i]
      if (filename) break
    }
  
    for (i = 0; i < set.length; i++) {
      var pattern = set[i]
      var file = f
      if (options.matchBase && pattern.length === 1) {
        file = [filename]
      }
      var hit = this.matchOne(file, pattern, partial)
      if (hit) {
        if (options.flipNegate) return true
        return !this.negate
      }
    }
  
    // didn't get any hits.  this is success if it's a negative
    // pattern, failure otherwise.
    if (options.flipNegate) return false
    return this.negate
  }
  
  // set partial to true to test if, for example,
  // "/a/b" matches the start of "/*/b/*/d"
  // Partial means, if you run out of file before you run
  // out of pattern, then that's fine, as long as all
  // the parts match.
  Minimatch.prototype.matchOne = function (file, pattern, partial) {
    var options = this.options
  
    this.debug('matchOne',
      { 'this': this, file: file, pattern: pattern })
  
    this.debug('matchOne', file.length, pattern.length)
  
    for (var fi = 0,
        pi = 0,
        fl = file.length,
        pl = pattern.length
        ; (fi < fl) && (pi < pl)
        ; fi++, pi++) {
      this.debug('matchOne loop')
      var p = pattern[pi]
      var f = file[fi]
  
      this.debug(pattern, p, f)
  
      // should be impossible.
      // some invalid regexp stuff in the set.
      if (p === false) return false
  
      if (p === GLOBSTAR) {
        this.debug('GLOBSTAR', [pattern, p, f])
  
        // "**"
        // a/**/b/**/c would match the following:
        // a/b/x/y/z/c
        // a/x/y/z/b/c
        // a/b/x/b/x/c
        // a/b/c
        // To do this, take the rest of the pattern after
        // the **, and see if it would match the file remainder.
        // If so, return success.
        // If not, the ** "swallows" a segment, and try again.
        // This is recursively awful.
        //
        // a/**/b/**/c matching a/b/x/y/z/c
        // - a matches a
        // - doublestar
        //   - matchOne(b/x/y/z/c, b/**/c)
        //     - b matches b
        //     - doublestar
        //       - matchOne(x/y/z/c, c) -> no
        //       - matchOne(y/z/c, c) -> no
        //       - matchOne(z/c, c) -> no
        //       - matchOne(c, c) yes, hit
        var fr = fi
        var pr = pi + 1
        if (pr === pl) {
          this.debug('** at the end')
          // a ** at the end will just swallow the rest.
          // We have found a match.
          // however, it will not swallow /.x, unless
          // options.dot is set.
          // . and .. are *never* matched by **, for explosively
          // exponential reasons.
          for (; fi < fl; fi++) {
            if (file[fi] === '.' || file[fi] === '..' ||
              (!options.dot && file[fi].charAt(0) === '.')) return false
          }
          return true
        }
  
        // ok, let's see if we can swallow whatever we can.
        while (fr < fl) {
          var swallowee = file[fr]
  
          this.debug('\nglobstar while', file, fr, pattern, pr, swallowee)
  
          // XXX remove this slice.  Just pass the start index.
          if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
            this.debug('globstar found match!', fr, fl, swallowee)
            // found a match.
            return true
          } else {
            // can't swallow "." or ".." ever.
            // can only swallow ".foo" when explicitly asked.
            if (swallowee === '.' || swallowee === '..' ||
              (!options.dot && swallowee.charAt(0) === '.')) {
              this.debug('dot detected!', file, fr, pattern, pr)
              break
            }
  
            // ** swallows a segment, and continue.
            this.debug('globstar swallow a segment, and continue')
            fr++
          }
        }
  
        // no match was found.
        // However, in partial mode, we can't say this is necessarily over.
        // If there's more *pattern* left, then
        if (partial) {
          // ran out of file
          this.debug('\n>>> no match, partial?', file, fr, pattern, pr)
          if (fr === fl) return true
        }
        return false
      }
  
      // something other than **
      // non-magic patterns just have to match exactly
      // patterns with magic have been turned into regexps.
      var hit
      if (typeof p === 'string') {
        if (options.nocase) {
          hit = f.toLowerCase() === p.toLowerCase()
        } else {
          hit = f === p
        }
        this.debug('string match', p, f, hit)
      } else {
        hit = f.match(p)
        this.debug('pattern match', p, f, hit)
      }
  
      if (!hit) return false
    }
  
    // Note: ending in / means that we'll get a final ""
    // at the end of the pattern.  This can only match a
    // corresponding "" at the end of the file.
    // If the file ends in /, then it can only match a
    // a pattern that ends in /, unless the pattern just
    // doesn't have any more for it. But, a/b/ should *not*
    // match "a/b/*", even though "" matches against the
    // [^/]*? pattern, except in partial mode, where it might
    // simply not be reached yet.
    // However, a/b/ should still satisfy a/*
  
    // now either we fell off the end of the pattern, or we're done.
    if (fi === fl && pi === pl) {
      // ran out of pattern and filename at the same time.
      // an exact hit!
      return true
    } else if (fi === fl) {
      // ran out of file, but still had pattern left.
      // this is ok if we're doing the match as part of
      // a glob fs traversal.
      return partial
    } else if (pi === pl) {
      // ran out of pattern, still have file left.
      // this is only acceptable if we're on the very last
      // empty segment of a file with a trailing slash.
      // a/* should match a/b/
      var emptyFileEnd = (fi === fl - 1) && (file[fi] === '')
      return emptyFileEnd
    }
  
    // should be unreachable.
    throw new Error('wtf?')
  }
  
  // replace stuff like \* with *
  function globUnescape (s) {
    return s.replace(/\\(.)/g, '$1')
  }
  
  function regExpEscape (s) {
    return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&')
  }
  
  
  /***/ }),
  
  /***/ 4865:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  const minimatch = __nccwpck_require__(3973);
  const arrayUnion = __nccwpck_require__(9600);
  const arrayDiffer = __nccwpck_require__(6554);
  const arrify = __nccwpck_require__(1546);
  
  module.exports = (list, patterns, options = {}) => {
  	list = arrify(list);
  	patterns = arrify(patterns);
  
  	if (list.length === 0 || patterns.length === 0) {
  		return [];
  	}
  
  	let result = [];
  	for (const item of list) {
  		for (let pattern of patterns) {
  			let process = arrayUnion;
  
  			if (pattern[0] === '!') {
  				pattern = pattern.slice(1);
  				process = arrayDiffer;
  			}
  
  			result = process(result, minimatch.match([item], pattern, options));
  		}
  	}
  
  	return result;
  };
  
  
  /***/ }),
  
  /***/ 7816:
  /***/ ((module) => {
  
  "use strict";
  
  module.exports = milliseconds => {
  	if (typeof milliseconds !== 'number') {
  		throw new TypeError('Expected a number');
  	}
  
  	const roundTowardsZero = milliseconds > 0 ? Math.floor : Math.ceil;
  
  	return {
  		days: roundTowardsZero(milliseconds / 86400000),
  		hours: roundTowardsZero(milliseconds / 3600000) % 24,
  		minutes: roundTowardsZero(milliseconds / 60000) % 60,
  		seconds: roundTowardsZero(milliseconds / 1000) % 60,
  		milliseconds: roundTowardsZero(milliseconds) % 1000,
  		microseconds: roundTowardsZero(milliseconds * 1000) % 1000,
  		nanoseconds: roundTowardsZero(milliseconds * 1e6) % 1000
  	};
  };
  
  
  /***/ }),
  
  /***/ 5168:
  /***/ ((module) => {
  
  "use strict";
  
  
  const BYTE_UNITS = [
  	'B',
  	'kB',
  	'MB',
  	'GB',
  	'TB',
  	'PB',
  	'EB',
  	'ZB',
  	'YB'
  ];
  
  const BIBYTE_UNITS = [
  	'B',
  	'kiB',
  	'MiB',
  	'GiB',
  	'TiB',
  	'PiB',
  	'EiB',
  	'ZiB',
  	'YiB'
  ];
  
  const BIT_UNITS = [
  	'b',
  	'kbit',
  	'Mbit',
  	'Gbit',
  	'Tbit',
  	'Pbit',
  	'Ebit',
  	'Zbit',
  	'Ybit'
  ];
  
  const BIBIT_UNITS = [
  	'b',
  	'kibit',
  	'Mibit',
  	'Gibit',
  	'Tibit',
  	'Pibit',
  	'Eibit',
  	'Zibit',
  	'Yibit'
  ];
  
  /*
  Formats the given number using `Number#toLocaleString`.
  - If locale is a string, the value is expected to be a locale-key (for example: `de`).
  - If locale is true, the system default locale is used for translation.
  - If no value for locale is specified, the number is returned unmodified.
  */
  const toLocaleString = (number, locale, options) => {
  	let result = number;
  	if (typeof locale === 'string' || Array.isArray(locale)) {
  		result = number.toLocaleString(locale, options);
  	} else if (locale === true || options !== undefined) {
  		result = number.toLocaleString(undefined, options);
  	}
  
  	return result;
  };
  
  module.exports = (number, options) => {
  	if (!Number.isFinite(number)) {
  		throw new TypeError(`Expected a finite number, got ${typeof number}: ${number}`);
  	}
  
  	options = Object.assign({bits: false, binary: false}, options);
  
  	const UNITS = options.bits ?
  		(options.binary ? BIBIT_UNITS : BIT_UNITS) :
  		(options.binary ? BIBYTE_UNITS : BYTE_UNITS);
  
  	if (options.signed && number === 0) {
  		return ` 0 ${UNITS[0]}`;
  	}
  
  	const isNegative = number < 0;
  	const prefix = isNegative ? '-' : (options.signed ? '+' : '');
  
  	if (isNegative) {
  		number = -number;
  	}
  
  	let localeOptions;
  
  	if (options.minimumFractionDigits !== undefined) {
  		localeOptions = {minimumFractionDigits: options.minimumFractionDigits};
  	}
  
  	if (options.maximumFractionDigits !== undefined) {
  		localeOptions = Object.assign({maximumFractionDigits: options.maximumFractionDigits}, localeOptions);
  	}
  
  	if (number < 1) {
  		const numberString = toLocaleString(number, options.locale, localeOptions);
  		return prefix + numberString + ' ' + UNITS[0];
  	}
  
  	const exponent = Math.min(Math.floor(options.binary ? Math.log(number) / Math.log(1024) : Math.log10(number) / 3), UNITS.length - 1);
  	// eslint-disable-next-line unicorn/prefer-exponentiation-operator
  	number /= Math.pow(options.binary ? 1024 : 1000, exponent);
  
  	if (!localeOptions) {
  		number = number.toPrecision(3);
  	}
  
  	const numberString = toLocaleString(Number(number), options.locale, localeOptions);
  
  	const unit = UNITS[exponent];
  
  	return prefix + numberString + ' ' + unit;
  };
  
  
  /***/ }),
  
  /***/ 1127:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  const parseMilliseconds = __nccwpck_require__(7816);
  
  const pluralize = (word, count) => count === 1 ? word : `${word}s`;
  
  const SECOND_ROUNDING_EPSILON = 0.0000001;
  
  module.exports = (milliseconds, options = {}) => {
  	if (!Number.isFinite(milliseconds)) {
  		throw new TypeError('Expected a finite number');
  	}
  
  	if (options.colonNotation) {
  		options.compact = false;
  		options.formatSubMilliseconds = false;
  		options.separateMilliseconds = false;
  		options.verbose = false;
  	}
  
  	if (options.compact) {
  		options.secondsDecimalDigits = 0;
  		options.millisecondsDecimalDigits = 0;
  	}
  
  	const result = [];
  
  	const floorDecimals = (value, decimalDigits) => {
  		const flooredInterimValue = Math.floor((value * (10 ** decimalDigits)) + SECOND_ROUNDING_EPSILON);
  		const flooredValue = Math.round(flooredInterimValue) / (10 ** decimalDigits);
  		return flooredValue.toFixed(decimalDigits);
  	};
  
  	const add = (value, long, short, valueString) => {
  		if ((result.length === 0 || !options.colonNotation) && value === 0 && !(options.colonNotation && short === 'm')) {
  			return;
  		}
  
  		valueString = (valueString || value || '0').toString();
  		let prefix;
  		let suffix;
  		if (options.colonNotation) {
  			prefix = result.length > 0 ? ':' : '';
  			suffix = '';
  			const wholeDigits = valueString.includes('.') ? valueString.split('.')[0].length : valueString.length;
  			const minLength = result.length > 0 ? 2 : 1;
  			valueString = '0'.repeat(Math.max(0, minLength - wholeDigits)) + valueString;
  		} else {
  			prefix = '';
  			suffix = options.verbose ? ' ' + pluralize(long, value) : short;
  		}
  
  		result.push(prefix + valueString + suffix);
  	};
  
  	const parsed = parseMilliseconds(milliseconds);
  
  	add(Math.trunc(parsed.days / 365), 'year', 'y');
  	add(parsed.days % 365, 'day', 'd');
  	add(parsed.hours, 'hour', 'h');
  	add(parsed.minutes, 'minute', 'm');
  
  	if (
  		options.separateMilliseconds ||
  		options.formatSubMilliseconds ||
  		(!options.colonNotation && milliseconds < 1000)
  	) {
  		add(parsed.seconds, 'second', 's');
  		if (options.formatSubMilliseconds) {
  			add(parsed.milliseconds, 'millisecond', 'ms');
  			add(parsed.microseconds, 'microsecond', 'µs');
  			add(parsed.nanoseconds, 'nanosecond', 'ns');
  		} else {
  			const millisecondsAndBelow =
  				parsed.milliseconds +
  				(parsed.microseconds / 1000) +
  				(parsed.nanoseconds / 1e6);
  
  			const millisecondsDecimalDigits =
  				typeof options.millisecondsDecimalDigits === 'number' ?
  					options.millisecondsDecimalDigits :
  					0;
  
  			const roundedMiliseconds = millisecondsAndBelow >= 1 ?
  				Math.round(millisecondsAndBelow) :
  				Math.ceil(millisecondsAndBelow);
  
  			const millisecondsString = millisecondsDecimalDigits ?
  				millisecondsAndBelow.toFixed(millisecondsDecimalDigits) :
  				roundedMiliseconds;
  
  			add(
  				Number.parseFloat(millisecondsString, 10),
  				'millisecond',
  				'ms',
  				millisecondsString
  			);
  		}
  	} else {
  		const seconds = (milliseconds / 1000) % 60;
  		const secondsDecimalDigits =
  			typeof options.secondsDecimalDigits === 'number' ?
  				options.secondsDecimalDigits :
  				1;
  		const secondsFixed = floorDecimals(seconds, secondsDecimalDigits);
  		const secondsString = options.keepDecimalsOnWholeSeconds ?
  			secondsFixed :
  			secondsFixed.replace(/\.0+$/, '');
  		add(Number.parseFloat(secondsString, 10), 'second', 's', secondsString);
  	}
  
  	if (result.length === 0) {
  		return '0' + (options.verbose ? ' milliseconds' : 'ms');
  	}
  
  	if (options.compact) {
  		return result[0];
  	}
  
  	if (typeof options.unitCount === 'number') {
  		const separator = options.colonNotation ? '' : ' ';
  		return result.slice(0, Math.max(options.unitCount, 1)).join(separator);
  	}
  
  	return options.colonNotation ? result.join('') : result.join(' ');
  };
  
  
  /***/ }),
  
  /***/ 6417:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("crypto");;
  
  /***/ }),
  
  /***/ 5747:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("fs");;
  
  /***/ }),
  
  /***/ 1631:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("net");;
  
  /***/ }),
  
  /***/ 2087:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("os");;
  
  /***/ }),
  
  /***/ 5622:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("path");;
  
  /***/ }),
  
  /***/ 2413:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("stream");;
  
  /***/ }),
  
  /***/ 4016:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("tls");;
  
  /***/ }),
  
  /***/ 1669:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("util");;
  
  /***/ })
  
  /******/ 	});
  /************************************************************************/
  /******/ 	// The module cache
  /******/ 	var __webpack_module_cache__ = {};
  /******/ 	
  /******/ 	// The require function
  /******/ 	function __nccwpck_require__(moduleId) {
  /******/ 		// Check if module is in cache
  /******/ 		var cachedModule = __webpack_module_cache__[moduleId];
  /******/ 		if (cachedModule !== undefined) {
  /******/ 			return cachedModule.exports;
  /******/ 		}
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = __webpack_module_cache__[moduleId] = {
  /******/ 			// no module.id needed
  /******/ 			// no module.loaded needed
  /******/ 			exports: {}
  /******/ 		};
  /******/ 	
  /******/ 		// Execute the module function
  /******/ 		var threw = true;
  /******/ 		try {
  /******/ 			__webpack_modules__[moduleId].call(module.exports, module, module.exports, __nccwpck_require__);
  /******/ 			threw = false;
  /******/ 		} finally {
  /******/ 			if(threw) delete __webpack_module_cache__[moduleId];
  /******/ 		}
  /******/ 	
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  /******/ 	
  /************************************************************************/
  /******/ 	/* webpack/runtime/make namespace object */
  /******/ 	(() => {
  /******/ 		// define __esModule on exports
  /******/ 		__nccwpck_require__.r = (exports) => {
  /******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
  /******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
  /******/ 			}
  /******/ 			Object.defineProperty(exports, '__esModule', { value: true });
  /******/ 		};
  /******/ 	})();
  /******/ 	
  /******/ 	/* webpack/runtime/compat */
  /******/ 	
  /******/ 	if (typeof __nccwpck_require__ !== 'undefined') __nccwpck_require__.ab = __dirname + "/";/************************************************************************/
  var __webpack_exports__ = {};
  // This entry need to be wrapped in an IIFE because it need to be in strict mode.
  (() => {
  "use strict";
  // ESM COMPAT FLAG
  __nccwpck_require__.r(__webpack_exports__);
  
  // EXTERNAL MODULE: ./node_modules/@actions/core/lib/core.js
  var core = __nccwpck_require__(2186);
  // EXTERNAL MODULE: ./node_modules/@devrma/ftp-deploy/dist/module.js
  var dist_module = __nccwpck_require__(8347);
  ;// CONCATENATED MODULE: ./src/parse.ts
  function optionalString(rawValue) {
      if (rawValue.length === 0) {
          return undefined;
      }
      return rawValue;
  }
  function optionalBoolean(argumentName, rawValue) {
      if (rawValue.length === 0) {
          return undefined;
      }
      const cleanValue = rawValue.toLowerCase();
      if (cleanValue === "true") {
          return true;
      }
      if (cleanValue === "false") {
          return false;
      }
      throw new Error(`${argumentName}: invalid parameter - please use a boolean, you provided "${rawValue}". Try true or false instead.`);
  }
  function optionalProtocol(argumentName, rawValue) {
      if (rawValue.length === 0) {
          return undefined;
      }
      const cleanValue = rawValue.toLowerCase();
      if (cleanValue === "ftp") {
          return "ftp";
      }
      if (cleanValue === "ftps") {
          return "ftps";
      }
      if (cleanValue === "ftps-legacy") {
          return "ftps-legacy";
      }
      throw new Error(`${argumentName}: invalid parameter - you provided "${rawValue}". Try "ftp", "ftps", or "ftps-legacy" instead.`);
  }
  function optionalLogLevel(argumentName, rawValue) {
      if (rawValue.length === 0) {
          return undefined;
      }
      const cleanValue = rawValue.toLowerCase();
      if (cleanValue === "minimal") {
          return "minimal";
      }
      if (cleanValue === "standard") {
          return "standard";
      }
      if (cleanValue === "verbose") {
          return "verbose";
      }
      throw new Error(`${argumentName}: invalid parameter - you provided "${rawValue}". Try "minimal", "standard", or "verbose" instead.`);
  }
  function optionalSecurity(argumentName, rawValue) {
      if (rawValue.length === 0) {
          return undefined;
      }
      const cleanValue = rawValue.toLowerCase();
      if (cleanValue === "loose") {
          return "loose";
      }
      if (cleanValue === "strict") {
          return "strict";
      }
      throw new Error(`${argumentName}: invalid parameter - you provided "${rawValue}". Try "loose" or "strict" instead.`);
  }
  function optionalInt(argumentName, rawValue) {
      if (rawValue.length === 0) {
          return undefined;
      }
      const valueAsNumber = parseFloat(rawValue);
      if (Number.isInteger(valueAsNumber)) {
          return valueAsNumber;
      }
      throw new Error(`${argumentName}: invalid parameter - you provided "${rawValue}". Try a whole number (no decimals) instead like 1234`);
  }
  function optionalStringArray(argumentName, rawValue) {
      if (rawValue.length === 0) {
          return undefined;
      }
      const valueTrim = rawValue.trim();
      if (valueTrim.startsWith("[")) {
          // remove [ and ] - then convert to array
          return rawValue.replace(/[\[\]]/g, "").trim().split(", ").filter(str => str !== "");
      }
      // split value by space and comma
      const valueAsArrayDouble = rawValue.split(" - ").map(str => str.trim()).filter(str => str !== "");
      if (valueAsArrayDouble.length) {
          return valueAsArrayDouble;
      }
      throw new Error(`${argumentName}: invalid parameter - you provided "${rawValue}". This option excepts an array in the format [val1, val2] or val1\/n - val2`);
  }
  
  ;// CONCATENATED MODULE: ./src/main.ts
  
  
  
  async function runDeployment() {
      try {
          const args = {
              server: core.getInput("server", { required: true }),
              username: core.getInput("username", { required: true }),
              password: core.getInput("password", { required: true }),
              port: optionalInt("port", core.getInput("port")),
              protocol: optionalProtocol("protocol", core.getInput("protocol")),
              "local-dir": optionalString(core.getInput("local-dir")),
              "server-dir": optionalString(core.getInput("server-dir")),
              "state-name": optionalString(core.getInput("state-name")),
              "dry-run": optionalBoolean("dry-run", core.getInput("dry-run")),
              "dangerous-clean-slate": optionalBoolean("dangerous-clean-slate", core.getInput("dangerous-clean-slate")),
              "exclude": optionalStringArray("exclude", core.getInput("exclude")),
              "log-level": optionalLogLevel("log-level", core.getInput("log-level")),
              "security": optionalSecurity("security", core.getInput("security"))
          };
          await (0,dist_module.deploy)(args);
      }
      catch (error) {
          core.setFailed(error);
      }
  }
  runDeployment();
  
  })();
  
  module.exports = __webpack_exports__;
  /******/ })()
  ;