text: module.exports =
  /******/ (() => { // webpackBootstrap
  /******/ 	var __webpack_modules__ = ({
  
  /***/ 4582:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const core = __nccwpck_require__(2186);
  const exec = __nccwpck_require__(1514);
  const keyValueAsService = __nccwpck_require__(5241);
  const coverage = __nccwpck_require__(382);
  const badge = __nccwpck_require__(4166);
  
  module.exports.run = async () => {
    const testCommand = core.getInput('test-command');
    await exec.exec(testCommand);
  
    const coverageType = getCoverageType();
    const coveragePercentage = await coverage.percentage('./coverage/clover.xml', coverageType);
  
    const schema = getCoverageSchema(coveragePercentage);
  
    const kvaasKeyUrl = await getKeyValueAsServiceUrl();
    await keyValueAsService.setKeyValue(kvaasKeyUrl, schema);
  
    core.setOutput('BADGE_URL', encodeURI(`https://img.shields.io/endpoint?url=${kvaasKeyUrl}`));
  };
  
  const getCoverageType = () => {
    const coverageType = core.getInput('coverage-type');
    if (!coverage.isValidType(coverageType)) throw new Error('Input coverage-type is not recognized');
    return coverageType;
  };
  
  const getKeyValueAsServiceUrl = async () => {
    const kvaasKeyUrl = core.getInput('kvaas-key-url');
    if (!kvaasKeyUrl) {
      return await keyValueAsService.createNewUrl();
    }
  
    if (!keyValueAsService.isUrlValid(kvaasKeyUrl)) throw new Error('Input kvaas-key-url is not valid');
    return kvaasKeyUrl;
  };
  
  const getCoverageSchema = (coveragePercentage) => {
    const colorConfiguration = JSON.parse(core.getInput('badge-color-configuration'));
    const label = core.getInput('badge-label');
    const showJestLogo = core.getInput('badge-logo');
  
    return badge.schema(coveragePercentage, label, colorConfiguration, showJestLogo);
  };
  
  
  /***/ }),
  
  /***/ 4166:
  /***/ ((module) => {
  
  module.exports.schema = (coveragePercentage, label, colorConfiguration, showJestLogo) => {
    let color = getColor(colorConfiguration, coveragePercentage);
  
    if (!color) color = 'blue';
  
    const schema = {
      schemaVersion: 1,
      label: label,
      message: `${coveragePercentage}%`,
      color: color,
    };
  
    if (showJestLogo) schema.namedLogo = 'jest';
  
    return schema;
  };
  
  const getColor = (colorConfiguration, coverage) => {
    const configsFound = colorConfiguration
        .filter((config) => (!config['>=']) || (config['>='] && coverage>=config['>=']))
        .filter((config) => (!config['<='] || config['<='] && coverage<=config['<=']))
        .filter((config) => (!config['>'] || config['>'] && coverage>config['>']))
        .filter((config) => (!config['<'] || config['<'] && coverage<config['<']))
        .map((config) => config.color);
    return configsFound.shift();
  };
  
  
  /***/ }),
  
  /***/ 382:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const xml2js = __nccwpck_require__(6189);
  const fs = __nccwpck_require__(5747);
  const coverageTypes = ['statements', 'methods', 'conditionals'];
  
  module.exports = {
    isValidType: (type) => {
      return coverageTypes.includes(type);
    },
  
    percentage: async (filePath, type) => {
      const xmlFile = fs.readFileSync(filePath);
      const xmlFileData = await xml2js.parseStringPromise(xmlFile);
      const metrics = xmlFileData.coverage.project[0].metrics[0].$;
  
      const total = parseInt(metrics[type]);
      const covered = parseInt(metrics[`covered${type}`]);
  
      if (total == 0) return 0;
  
      const coverageRatio = covered/total;
  
      return parseFloat((coverageRatio*100).toFixed(2));
    },
  
  
  };
  
  
  /***/ }),
  
  /***/ 2932:
  /***/ ((__unused_webpack_module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const action = __nccwpck_require__(4582);
  const core = __nccwpck_require__(2186);
  
  action.run().catch((err) => core.setFailed(err.message));
  
  
  /***/ }),
  
  /***/ 5241:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  const fetch = __nccwpck_require__(467);
  const retry = __nccwpck_require__(2548);
  const baseUrl = 'https://api.keyvalue.xyz';
  
  module.exports = {
  
    isUrlValid: (url) => {
      return /^https:\/\/api\.keyvalue\.xyz\/[a-zA-Z0-9_-]+\/[a-zA-Z0-9_-]+$/.test(url);
    },
  
    createNewUrl: async () => {
      const response = await retry(() => fetch(`${baseUrl}/new/coverage`, {method: 'post', timeout: 1000}), {retries: 3});
      const url = await response.text();
      return url.replace('\n', '');
    },
  
    setKeyValue: async (url, objectValue) => {
      const response = await retry(() => fetch(url, {
        method: 'post',
        body: JSON.stringify(objectValue),
        headers: {'Content-Type': 'text/plain'},
        timeout: 1000,
      }), {retries: 3});
      const data = await response.text();
      return data;
    },
  };
  
  
  /***/ }),
  
  /***/ 7351:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  "use strict";
  
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
      result["default"] = mod;
      return result;
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  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 __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 __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
      result["default"] = mod;
      return result;
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  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.  The value is also trimmed.
   *
   * @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}`);
      }
      return val.trim();
  }
  exports.getInput = getInput;
  /**
   * 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) {
      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 __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
      result["default"] = mod;
      return result;
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  // 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 }));
  /**
   * 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
  
  /***/ }),
  
  /***/ 1514:
  /***/ (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 __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
      result["default"] = mod;
      return result;
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  const tr = __importStar(__nccwpck_require__(8159));
  /**
   * Exec a command.
   * Output will be streamed to the live console.
   * Returns promise with return code
   *
   * @param     commandLine        command to execute (can include additional args). Must be correctly escaped.
   * @param     args               optional arguments for tool. Escaping is handled by the lib.
   * @param     options            optional exec options.  See ExecOptions
   * @returns   Promise<number>    exit code
   */
  function exec(commandLine, args, options) {
      return __awaiter(this, void 0, void 0, function* () {
          const commandArgs = tr.argStringToArray(commandLine);
          if (commandArgs.length === 0) {
              throw new Error(`Parameter 'commandLine' cannot be null or empty.`);
          }
          // Path to tool to execute should be first arg
          const toolPath = commandArgs[0];
          args = commandArgs.slice(1).concat(args || []);
          const runner = new tr.ToolRunner(toolPath, args, options);
          return runner.exec();
      });
  }
  exports.exec = exec;
  //# sourceMappingURL=exec.js.map
  
  /***/ }),
  
  /***/ 8159:
  /***/ (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 __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
      result["default"] = mod;
      return result;
  };
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  const os = __importStar(__nccwpck_require__(2087));
  const events = __importStar(__nccwpck_require__(8614));
  const child = __importStar(__nccwpck_require__(3129));
  const path = __importStar(__nccwpck_require__(5622));
  const io = __importStar(__nccwpck_require__(7436));
  const ioUtil = __importStar(__nccwpck_require__(1962));
  /* eslint-disable @typescript-eslint/unbound-method */
  const IS_WINDOWS = process.platform === 'win32';
  /*
   * Class for running command line tools. Handles quoting and arg parsing in a platform agnostic way.
   */
  class ToolRunner extends events.EventEmitter {
      constructor(toolPath, args, options) {
          super();
          if (!toolPath) {
              throw new Error("Parameter 'toolPath' cannot be null or empty.");
          }
          this.toolPath = toolPath;
          this.args = args || [];
          this.options = options || {};
      }
      _debug(message) {
          if (this.options.listeners && this.options.listeners.debug) {
              this.options.listeners.debug(message);
          }
      }
      _getCommandString(options, noPrefix) {
          const toolPath = this._getSpawnFileName();
          const args = this._getSpawnArgs(options);
          let cmd = noPrefix ? '' : '[command]'; // omit prefix when piped to a second tool
          if (IS_WINDOWS) {
              // Windows + cmd file
              if (this._isCmdFile()) {
                  cmd += toolPath;
                  for (const a of args) {
                      cmd += ` ${a}`;
                  }
              }
              // Windows + verbatim
              else if (options.windowsVerbatimArguments) {
                  cmd += `"${toolPath}"`;
                  for (const a of args) {
                      cmd += ` ${a}`;
                  }
              }
              // Windows (regular)
              else {
                  cmd += this._windowsQuoteCmdArg(toolPath);
                  for (const a of args) {
                      cmd += ` ${this._windowsQuoteCmdArg(a)}`;
                  }
              }
          }
          else {
              // OSX/Linux - this can likely be improved with some form of quoting.
              // creating processes on Unix is fundamentally different than Windows.
              // on Unix, execvp() takes an arg array.
              cmd += toolPath;
              for (const a of args) {
                  cmd += ` ${a}`;
              }
          }
          return cmd;
      }
      _processLineBuffer(data, strBuffer, onLine) {
          try {
              let s = strBuffer + data.toString();
              let n = s.indexOf(os.EOL);
              while (n > -1) {
                  const line = s.substring(0, n);
                  onLine(line);
                  // the rest of the string ...
                  s = s.substring(n + os.EOL.length);
                  n = s.indexOf(os.EOL);
              }
              strBuffer = s;
          }
          catch (err) {
              // streaming lines to console is best effort.  Don't fail a build.
              this._debug(`error processing line. Failed with error ${err}`);
          }
      }
      _getSpawnFileName() {
          if (IS_WINDOWS) {
              if (this._isCmdFile()) {
                  return process.env['COMSPEC'] || 'cmd.exe';
              }
          }
          return this.toolPath;
      }
      _getSpawnArgs(options) {
          if (IS_WINDOWS) {
              if (this._isCmdFile()) {
                  let argline = `/D /S /C "${this._windowsQuoteCmdArg(this.toolPath)}`;
                  for (const a of this.args) {
                      argline += ' ';
                      argline += options.windowsVerbatimArguments
                          ? a
                          : this._windowsQuoteCmdArg(a);
                  }
                  argline += '"';
                  return [argline];
              }
          }
          return this.args;
      }
      _endsWith(str, end) {
          return str.endsWith(end);
      }
      _isCmdFile() {
          const upperToolPath = this.toolPath.toUpperCase();
          return (this._endsWith(upperToolPath, '.CMD') ||
              this._endsWith(upperToolPath, '.BAT'));
      }
      _windowsQuoteCmdArg(arg) {
          // for .exe, apply the normal quoting rules that libuv applies
          if (!this._isCmdFile()) {
              return this._uvQuoteCmdArg(arg);
          }
          // otherwise apply quoting rules specific to the cmd.exe command line parser.
          // the libuv rules are generic and are not designed specifically for cmd.exe
          // command line parser.
          //
          // for a detailed description of the cmd.exe command line parser, refer to
          // http://stackoverflow.com/questions/4094699/how-does-the-windows-command-interpreter-cmd-exe-parse-scripts/7970912#7970912
          // need quotes for empty arg
          if (!arg) {
              return '""';
          }
          // determine whether the arg needs to be quoted
          const cmdSpecialChars = [
              ' ',
              '\t',
              '&',
              '(',
              ')',
              '[',
              ']',
              '{',
              '}',
              '^',
              '=',
              ';',
              '!',
              "'",
              '+',
              ',',
              '`',
              '~',
              '|',
              '<',
              '>',
              '"'
          ];
          let needsQuotes = false;
          for (const char of arg) {
              if (cmdSpecialChars.some(x => x === char)) {
                  needsQuotes = true;
                  break;
              }
          }
          // short-circuit if quotes not needed
          if (!needsQuotes) {
              return arg;
          }
          // the following quoting rules are very similar to the rules that by libuv applies.
          //
          // 1) wrap the string in quotes
          //
          // 2) double-up quotes - i.e. " => ""
          //
          //    this is different from the libuv quoting rules. libuv replaces " with \", which unfortunately
          //    doesn't work well with a cmd.exe command line.
          //
          //    note, replacing " with "" also works well if the arg is passed to a downstream .NET console app.
          //    for example, the command line:
          //          foo.exe "myarg:""my val"""
          //    is parsed by a .NET console app into an arg array:
          //          [ "myarg:\"my val\"" ]
          //    which is the same end result when applying libuv quoting rules. although the actual
          //    command line from libuv quoting rules would look like:
          //          foo.exe "myarg:\"my val\""
          //
          // 3) double-up slashes that precede a quote,
          //    e.g.  hello \world    => "hello \world"
          //          hello\"world    => "hello\\""world"
          //          hello\\"world   => "hello\\\\""world"
          //          hello world\    => "hello world\\"
          //
          //    technically this is not required for a cmd.exe command line, or the batch argument parser.
          //    the reasons for including this as a .cmd quoting rule are:
          //
          //    a) this is optimized for the scenario where the argument is passed from the .cmd file to an
          //       external program. many programs (e.g. .NET console apps) rely on the slash-doubling rule.
          //
          //    b) it's what we've been doing previously (by deferring to node default behavior) and we
          //       haven't heard any complaints about that aspect.
          //
          // note, a weakness of the quoting rules chosen here, is that % is not escaped. in fact, % cannot be
          // escaped when used on the command line directly - even though within a .cmd file % can be escaped
          // by using %%.
          //
          // the saving grace is, on the command line, %var% is left as-is if var is not defined. this contrasts
          // the line parsing rules within a .cmd file, where if var is not defined it is replaced with nothing.
          //
          // one option that was explored was replacing % with ^% - i.e. %var% => ^%var^%. this hack would
          // often work, since it is unlikely that var^ would exist, and the ^ character is removed when the
          // variable is used. the problem, however, is that ^ is not removed when %* is used to pass the args
          // to an external program.
          //
          // an unexplored potential solution for the % escaping problem, is to create a wrapper .cmd file.
          // % can be escaped within a .cmd file.
          let reverse = '"';
          let quoteHit = true;
          for (let i = arg.length; i > 0; i--) {
              // walk the string in reverse
              reverse += arg[i - 1];
              if (quoteHit && arg[i - 1] === '\\') {
                  reverse += '\\'; // double the slash
              }
              else if (arg[i - 1] === '"') {
                  quoteHit = true;
                  reverse += '"'; // double the quote
              }
              else {
                  quoteHit = false;
              }
          }
          reverse += '"';
          return reverse
              .split('')
              .reverse()
              .join('');
      }
      _uvQuoteCmdArg(arg) {
          // Tool runner wraps child_process.spawn() and needs to apply the same quoting as
          // Node in certain cases where the undocumented spawn option windowsVerbatimArguments
          // is used.
          //
          // Since this function is a port of quote_cmd_arg from Node 4.x (technically, lib UV,
          // see https://github.com/nodejs/node/blob/v4.x/deps/uv/src/win/process.c for details),
          // pasting copyright notice from Node within this function:
          //
          //      Copyright Joyent, Inc. and other Node contributors. All rights reserved.
          //
          //      Permission is hereby granted, free of charge, to any person obtaining a copy
          //      of this software and associated documentation files (the "Software"), to
          //      deal in the Software without restriction, including without limitation the
          //      rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
          //      sell copies of the Software, and to permit persons to whom the Software is
          //      furnished to do so, subject to the following conditions:
          //
          //      The above copyright notice and this permission notice shall be included in
          //      all copies or substantial portions of the Software.
          //
          //      THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
          //      IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
          //      FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
          //      AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
          //      LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
          //      FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
          //      IN THE SOFTWARE.
          if (!arg) {
              // Need double quotation for empty argument
              return '""';
          }
          if (!arg.includes(' ') && !arg.includes('\t') && !arg.includes('"')) {
              // No quotation needed
              return arg;
          }
          if (!arg.includes('"') && !arg.includes('\\')) {
              // No embedded double quotes or backslashes, so I can just wrap
              // quote marks around the whole thing.
              return `"${arg}"`;
          }
          // Expected input/output:
          //   input : hello"world
          //   output: "hello\"world"
          //   input : hello""world
          //   output: "hello\"\"world"
          //   input : hello\world
          //   output: hello\world
          //   input : hello\\world
          //   output: hello\\world
          //   input : hello\"world
          //   output: "hello\\\"world"
          //   input : hello\\"world
          //   output: "hello\\\\\"world"
          //   input : hello world\
          //   output: "hello world\\" - note the comment in libuv actually reads "hello world\"
          //                             but it appears the comment is wrong, it should be "hello world\\"
          let reverse = '"';
          let quoteHit = true;
          for (let i = arg.length; i > 0; i--) {
              // walk the string in reverse
              reverse += arg[i - 1];
              if (quoteHit && arg[i - 1] === '\\') {
                  reverse += '\\';
              }
              else if (arg[i - 1] === '"') {
                  quoteHit = true;
                  reverse += '\\';
              }
              else {
                  quoteHit = false;
              }
          }
          reverse += '"';
          return reverse
              .split('')
              .reverse()
              .join('');
      }
      _cloneExecOptions(options) {
          options = options || {};
          const result = {
              cwd: options.cwd || process.cwd(),
              env: options.env || process.env,
              silent: options.silent || false,
              windowsVerbatimArguments: options.windowsVerbatimArguments || false,
              failOnStdErr: options.failOnStdErr || false,
              ignoreReturnCode: options.ignoreReturnCode || false,
              delay: options.delay || 10000
          };
          result.outStream = options.outStream || process.stdout;
          result.errStream = options.errStream || process.stderr;
          return result;
      }
      _getSpawnOptions(options, toolPath) {
          options = options || {};
          const result = {};
          result.cwd = options.cwd;
          result.env = options.env;
          result['windowsVerbatimArguments'] =
              options.windowsVerbatimArguments || this._isCmdFile();
          if (options.windowsVerbatimArguments) {
              result.argv0 = `"${toolPath}"`;
          }
          return result;
      }
      /**
       * Exec a tool.
       * Output will be streamed to the live console.
       * Returns promise with return code
       *
       * @param     tool     path to tool to exec
       * @param     options  optional exec options.  See ExecOptions
       * @returns   number
       */
      exec() {
          return __awaiter(this, void 0, void 0, function* () {
              // root the tool path if it is unrooted and contains relative pathing
              if (!ioUtil.isRooted(this.toolPath) &&
                  (this.toolPath.includes('/') ||
                      (IS_WINDOWS && this.toolPath.includes('\\')))) {
                  // prefer options.cwd if it is specified, however options.cwd may also need to be rooted
                  this.toolPath = path.resolve(process.cwd(), this.options.cwd || process.cwd(), this.toolPath);
              }
              // if the tool is only a file name, then resolve it from the PATH
              // otherwise verify it exists (add extension on Windows if necessary)
              this.toolPath = yield io.which(this.toolPath, true);
              return new Promise((resolve, reject) => {
                  this._debug(`exec tool: ${this.toolPath}`);
                  this._debug('arguments:');
                  for (const arg of this.args) {
                      this._debug(`   ${arg}`);
                  }
                  const optionsNonNull = this._cloneExecOptions(this.options);
                  if (!optionsNonNull.silent && optionsNonNull.outStream) {
                      optionsNonNull.outStream.write(this._getCommandString(optionsNonNull) + os.EOL);
                  }
                  const state = new ExecState(optionsNonNull, this.toolPath);
                  state.on('debug', (message) => {
                      this._debug(message);
                  });
                  const fileName = this._getSpawnFileName();
                  const cp = child.spawn(fileName, this._getSpawnArgs(optionsNonNull), this._getSpawnOptions(this.options, fileName));
                  const stdbuffer = '';
                  if (cp.stdout) {
                      cp.stdout.on('data', (data) => {
                          if (this.options.listeners && this.options.listeners.stdout) {
                              this.options.listeners.stdout(data);
                          }
                          if (!optionsNonNull.silent && optionsNonNull.outStream) {
                              optionsNonNull.outStream.write(data);
                          }
                          this._processLineBuffer(data, stdbuffer, (line) => {
                              if (this.options.listeners && this.options.listeners.stdline) {
                                  this.options.listeners.stdline(line);
                              }
                          });
                      });
                  }
                  const errbuffer = '';
                  if (cp.stderr) {
                      cp.stderr.on('data', (data) => {
                          state.processStderr = true;
                          if (this.options.listeners && this.options.listeners.stderr) {
                              this.options.listeners.stderr(data);
                          }
                          if (!optionsNonNull.silent &&
                              optionsNonNull.errStream &&
                              optionsNonNull.outStream) {
                              const s = optionsNonNull.failOnStdErr
                                  ? optionsNonNull.errStream
                                  : optionsNonNull.outStream;
                              s.write(data);
                          }
                          this._processLineBuffer(data, errbuffer, (line) => {
                              if (this.options.listeners && this.options.listeners.errline) {
                                  this.options.listeners.errline(line);
                              }
                          });
                      });
                  }
                  cp.on('error', (err) => {
                      state.processError = err.message;
                      state.processExited = true;
                      state.processClosed = true;
                      state.CheckComplete();
                  });
                  cp.on('exit', (code) => {
                      state.processExitCode = code;
                      state.processExited = true;
                      this._debug(`Exit code ${code} received from tool '${this.toolPath}'`);
                      state.CheckComplete();
                  });
                  cp.on('close', (code) => {
                      state.processExitCode = code;
                      state.processExited = true;
                      state.processClosed = true;
                      this._debug(`STDIO streams have closed for tool '${this.toolPath}'`);
                      state.CheckComplete();
                  });
                  state.on('done', (error, exitCode) => {
                      if (stdbuffer.length > 0) {
                          this.emit('stdline', stdbuffer);
                      }
                      if (errbuffer.length > 0) {
                          this.emit('errline', errbuffer);
                      }
                      cp.removeAllListeners();
                      if (error) {
                          reject(error);
                      }
                      else {
                          resolve(exitCode);
                      }
                  });
                  if (this.options.input) {
                      if (!cp.stdin) {
                          throw new Error('child process missing stdin');
                      }
                      cp.stdin.end(this.options.input);
                  }
              });
          });
      }
  }
  exports.ToolRunner = ToolRunner;
  /**
   * Convert an arg string to an array of args. Handles escaping
   *
   * @param    argString   string of arguments
   * @returns  string[]    array of arguments
   */
  function argStringToArray(argString) {
      const args = [];
      let inQuotes = false;
      let escaped = false;
      let arg = '';
      function append(c) {
          // we only escape double quotes.
          if (escaped && c !== '"') {
              arg += '\\';
          }
          arg += c;
          escaped = false;
      }
      for (let i = 0; i < argString.length; i++) {
          const c = argString.charAt(i);
          if (c === '"') {
              if (!escaped) {
                  inQuotes = !inQuotes;
              }
              else {
                  append(c);
              }
              continue;
          }
          if (c === '\\' && escaped) {
              append(c);
              continue;
          }
          if (c === '\\' && inQuotes) {
              escaped = true;
              continue;
          }
          if (c === ' ' && !inQuotes) {
              if (arg.length > 0) {
                  args.push(arg);
                  arg = '';
              }
              continue;
          }
          append(c);
      }
      if (arg.length > 0) {
          args.push(arg.trim());
      }
      return args;
  }
  exports.argStringToArray = argStringToArray;
  class ExecState extends events.EventEmitter {
      constructor(options, toolPath) {
          super();
          this.processClosed = false; // tracks whether the process has exited and stdio is closed
          this.processError = '';
          this.processExitCode = 0;
          this.processExited = false; // tracks whether the process has exited
          this.processStderr = false; // tracks whether stderr was written to
          this.delay = 10000; // 10 seconds
          this.done = false;
          this.timeout = null;
          if (!toolPath) {
              throw new Error('toolPath must not be empty');
          }
          this.options = options;
          this.toolPath = toolPath;
          if (options.delay) {
              this.delay = options.delay;
          }
      }
      CheckComplete() {
          if (this.done) {
              return;
          }
          if (this.processClosed) {
              this._setResult();
          }
          else if (this.processExited) {
              this.timeout = setTimeout(ExecState.HandleTimeout, this.delay, this);
          }
      }
      _debug(message) {
          this.emit('debug', message);
      }
      _setResult() {
          // determine whether there is an error
          let error;
          if (this.processExited) {
              if (this.processError) {
                  error = new Error(`There was an error when attempting to execute the process '${this.toolPath}'. This may indicate the process failed to start. Error: ${this.processError}`);
              }
              else if (this.processExitCode !== 0 && !this.options.ignoreReturnCode) {
                  error = new Error(`The process '${this.toolPath}' failed with exit code ${this.processExitCode}`);
              }
              else if (this.processStderr && this.options.failOnStdErr) {
                  error = new Error(`The process '${this.toolPath}' failed because one or more lines were written to the STDERR stream`);
              }
          }
          // clear the timeout
          if (this.timeout) {
              clearTimeout(this.timeout);
              this.timeout = null;
          }
          this.done = true;
          this.emit('done', error, this.processExitCode);
      }
      static HandleTimeout(state) {
          if (state.done) {
              return;
          }
          if (!state.processClosed && state.processExited) {
              const message = `The STDIO streams did not close within ${state.delay /
                  1000} seconds of the exit event from process '${state.toolPath}'. This may indicate a child process inherited the STDIO streams and has not yet exited.`;
              state._debug(message);
          }
          state._setResult();
      }
  }
  //# sourceMappingURL=toolrunner.js.map
  
  /***/ }),
  
  /***/ 1962:
  /***/ (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 _a;
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  const assert_1 = __nccwpck_require__(2357);
  const fs = __nccwpck_require__(5747);
  const path = __nccwpck_require__(5622);
  _a = fs.promises, exports.chmod = _a.chmod, exports.copyFile = _a.copyFile, exports.lstat = _a.lstat, exports.mkdir = _a.mkdir, exports.readdir = _a.readdir, exports.readlink = _a.readlink, exports.rename = _a.rename, exports.rmdir = _a.rmdir, exports.stat = _a.stat, exports.symlink = _a.symlink, exports.unlink = _a.unlink;
  exports.IS_WINDOWS = process.platform === 'win32';
  function exists(fsPath) {
      return __awaiter(this, void 0, void 0, function* () {
          try {
              yield exports.stat(fsPath);
          }
          catch (err) {
              if (err.code === 'ENOENT') {
                  return false;
              }
              throw err;
          }
          return true;
      });
  }
  exports.exists = exists;
  function isDirectory(fsPath, useStat = false) {
      return __awaiter(this, void 0, void 0, function* () {
          const stats = useStat ? yield exports.stat(fsPath) : yield exports.lstat(fsPath);
          return stats.isDirectory();
      });
  }
  exports.isDirectory = isDirectory;
  /**
   * On OSX/Linux, true if path starts with '/'. On Windows, true for paths like:
   * \, \hello, \\hello\share, C:, and C:\hello (and corresponding alternate separator cases).
   */
  function isRooted(p) {
      p = normalizeSeparators(p);
      if (!p) {
          throw new Error('isRooted() parameter "p" cannot be empty');
      }
      if (exports.IS_WINDOWS) {
          return (p.startsWith('\\') || /^[A-Z]:/i.test(p) // e.g. \ or \hello or \\hello
          ); // e.g. C: or C:\hello
      }
      return p.startsWith('/');
  }
  exports.isRooted = isRooted;
  /**
   * Recursively create a directory at `fsPath`.
   *
   * This implementation is optimistic, meaning it attempts to create the full
   * path first, and backs up the path stack from there.
   *
   * @param fsPath The path to create
   * @param maxDepth The maximum recursion depth
   * @param depth The current recursion depth
   */
  function mkdirP(fsPath, maxDepth = 1000, depth = 1) {
      return __awaiter(this, void 0, void 0, function* () {
          assert_1.ok(fsPath, 'a path argument must be provided');
          fsPath = path.resolve(fsPath);
          if (depth >= maxDepth)
              return exports.mkdir(fsPath);
          try {
              yield exports.mkdir(fsPath);
              return;
          }
          catch (err) {
              switch (err.code) {
                  case 'ENOENT': {
                      yield mkdirP(path.dirname(fsPath), maxDepth, depth + 1);
                      yield exports.mkdir(fsPath);
                      return;
                  }
                  default: {
                      let stats;
                      try {
                          stats = yield exports.stat(fsPath);
                      }
                      catch (err2) {
                          throw err;
                      }
                      if (!stats.isDirectory())
                          throw err;
                  }
              }
          }
      });
  }
  exports.mkdirP = mkdirP;
  /**
   * Best effort attempt to determine whether a file exists and is executable.
   * @param filePath    file path to check
   * @param extensions  additional file extensions to try
   * @return if file exists and is executable, returns the file path. otherwise empty string.
   */
  function tryGetExecutablePath(filePath, extensions) {
      return __awaiter(this, void 0, void 0, function* () {
          let stats = undefined;
          try {
              // test file exists
              stats = yield exports.stat(filePath);
          }
          catch (err) {
              if (err.code !== 'ENOENT') {
                  // eslint-disable-next-line no-console
                  console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`);
              }
          }
          if (stats && stats.isFile()) {
              if (exports.IS_WINDOWS) {
                  // on Windows, test for valid extension
                  const upperExt = path.extname(filePath).toUpperCase();
                  if (extensions.some(validExt => validExt.toUpperCase() === upperExt)) {
                      return filePath;
                  }
              }
              else {
                  if (isUnixExecutable(stats)) {
                      return filePath;
                  }
              }
          }
          // try each extension
          const originalFilePath = filePath;
          for (const extension of extensions) {
              filePath = originalFilePath + extension;
              stats = undefined;
              try {
                  stats = yield exports.stat(filePath);
              }
              catch (err) {
                  if (err.code !== 'ENOENT') {
                      // eslint-disable-next-line no-console
                      console.log(`Unexpected error attempting to determine if executable file exists '${filePath}': ${err}`);
                  }
              }
              if (stats && stats.isFile()) {
                  if (exports.IS_WINDOWS) {
                      // preserve the case of the actual file (since an extension was appended)
                      try {
                          const directory = path.dirname(filePath);
                          const upperName = path.basename(filePath).toUpperCase();
                          for (const actualName of yield exports.readdir(directory)) {
                              if (upperName === actualName.toUpperCase()) {
                                  filePath = path.join(directory, actualName);
                                  break;
                              }
                          }
                      }
                      catch (err) {
                          // eslint-disable-next-line no-console
                          console.log(`Unexpected error attempting to determine the actual case of the file '${filePath}': ${err}`);
                      }
                      return filePath;
                  }
                  else {
                      if (isUnixExecutable(stats)) {
                          return filePath;
                      }
                  }
              }
          }
          return '';
      });
  }
  exports.tryGetExecutablePath = tryGetExecutablePath;
  function normalizeSeparators(p) {
      p = p || '';
      if (exports.IS_WINDOWS) {
          // convert slashes on Windows
          p = p.replace(/\//g, '\\');
          // remove redundant slashes
          return p.replace(/\\\\+/g, '\\');
      }
      // remove redundant slashes
      return p.replace(/\/\/+/g, '/');
  }
  // on Mac/Linux, test the execute bit
  //     R   W  X  R  W X R W X
  //   256 128 64 32 16 8 4 2 1
  function isUnixExecutable(stats) {
      return ((stats.mode & 1) > 0 ||
          ((stats.mode & 8) > 0 && stats.gid === process.getgid()) ||
          ((stats.mode & 64) > 0 && stats.uid === process.getuid()));
  }
  //# sourceMappingURL=io-util.js.map
  
  /***/ }),
  
  /***/ 7436:
  /***/ (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 }));
  const childProcess = __nccwpck_require__(3129);
  const path = __nccwpck_require__(5622);
  const util_1 = __nccwpck_require__(1669);
  const ioUtil = __nccwpck_require__(1962);
  const exec = util_1.promisify(childProcess.exec);
  /**
   * Copies a file or folder.
   * Based off of shelljs - https://github.com/shelljs/shelljs/blob/9237f66c52e5daa40458f94f9565e18e8132f5a6/src/cp.js
   *
   * @param     source    source path
   * @param     dest      destination path
   * @param     options   optional. See CopyOptions.
   */
  function cp(source, dest, options = {}) {
      return __awaiter(this, void 0, void 0, function* () {
          const { force, recursive } = readCopyOptions(options);
          const destStat = (yield ioUtil.exists(dest)) ? yield ioUtil.stat(dest) : null;
          // Dest is an existing file, but not forcing
          if (destStat && destStat.isFile() && !force) {
              return;
          }
          // If dest is an existing directory, should copy inside.
          const newDest = destStat && destStat.isDirectory()
              ? path.join(dest, path.basename(source))
              : dest;
          if (!(yield ioUtil.exists(source))) {
              throw new Error(`no such file or directory: ${source}`);
          }
          const sourceStat = yield ioUtil.stat(source);
          if (sourceStat.isDirectory()) {
              if (!recursive) {
                  throw new Error(`Failed to copy. ${source} is a directory, but tried to copy without recursive flag.`);
              }
              else {
                  yield cpDirRecursive(source, newDest, 0, force);
              }
          }
          else {
              if (path.relative(source, newDest) === '') {
                  // a file cannot be copied to itself
                  throw new Error(`'${newDest}' and '${source}' are the same file`);
              }
              yield copyFile(source, newDest, force);
          }
      });
  }
  exports.cp = cp;
  /**
   * Moves a path.
   *
   * @param     source    source path
   * @param     dest      destination path
   * @param     options   optional. See MoveOptions.
   */
  function mv(source, dest, options = {}) {
      return __awaiter(this, void 0, void 0, function* () {
          if (yield ioUtil.exists(dest)) {
              let destExists = true;
              if (yield ioUtil.isDirectory(dest)) {
                  // If dest is directory copy src into dest
                  dest = path.join(dest, path.basename(source));
                  destExists = yield ioUtil.exists(dest);
              }
              if (destExists) {
                  if (options.force == null || options.force) {
                      yield rmRF(dest);
                  }
                  else {
                      throw new Error('Destination already exists');
                  }
              }
          }
          yield mkdirP(path.dirname(dest));
          yield ioUtil.rename(source, dest);
      });
  }
  exports.mv = mv;
  /**
   * Remove a path recursively with force
   *
   * @param inputPath path to remove
   */
  function rmRF(inputPath) {
      return __awaiter(this, void 0, void 0, function* () {
          if (ioUtil.IS_WINDOWS) {
              // Node doesn't provide a delete operation, only an unlink function. This means that if the file is being used by another
              // program (e.g. antivirus), it won't be deleted. To address this, we shell out the work to rd/del.
              try {
                  if (yield ioUtil.isDirectory(inputPath, true)) {
                      yield exec(`rd /s /q "${inputPath}"`);
                  }
                  else {
                      yield exec(`del /f /a "${inputPath}"`);
                  }
              }
              catch (err) {
                  // if you try to delete a file that doesn't exist, desired result is achieved
                  // other errors are valid
                  if (err.code !== 'ENOENT')
                      throw err;
              }
              // Shelling out fails to remove a symlink folder with missing source, this unlink catches that
              try {
                  yield ioUtil.unlink(inputPath);
              }
              catch (err) {
                  // if you try to delete a file that doesn't exist, desired result is achieved
                  // other errors are valid
                  if (err.code !== 'ENOENT')
                      throw err;
              }
          }
          else {
              let isDir = false;
              try {
                  isDir = yield ioUtil.isDirectory(inputPath);
              }
              catch (err) {
                  // if you try to delete a file that doesn't exist, desired result is achieved
                  // other errors are valid
                  if (err.code !== 'ENOENT')
                      throw err;
                  return;
              }
              if (isDir) {
                  yield exec(`rm -rf "${inputPath}"`);
              }
              else {
                  yield ioUtil.unlink(inputPath);
              }
          }
      });
  }
  exports.rmRF = rmRF;
  /**
   * Make a directory.  Creates the full path with folders in between
   * Will throw if it fails
   *
   * @param   fsPath        path to create
   * @returns Promise<void>
   */
  function mkdirP(fsPath) {
      return __awaiter(this, void 0, void 0, function* () {
          yield ioUtil.mkdirP(fsPath);
      });
  }
  exports.mkdirP = mkdirP;
  /**
   * Returns path of a tool had the tool actually been invoked.  Resolves via paths.
   * If you check and the tool does not exist, it will throw.
   *
   * @param     tool              name of the tool
   * @param     check             whether to check if tool exists
   * @returns   Promise<string>   path to tool
   */
  function which(tool, check) {
      return __awaiter(this, void 0, void 0, function* () {
          if (!tool) {
              throw new Error("parameter 'tool' is required");
          }
          // recursive when check=true
          if (check) {
              const result = yield which(tool, false);
              if (!result) {
                  if (ioUtil.IS_WINDOWS) {
                      throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also verify the file has a valid extension for an executable file.`);
                  }
                  else {
                      throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also check the file mode to verify the file is executable.`);
                  }
              }
          }
          try {
              // build the list of extensions to try
              const extensions = [];
              if (ioUtil.IS_WINDOWS && process.env.PATHEXT) {
                  for (const extension of process.env.PATHEXT.split(path.delimiter)) {
                      if (extension) {
                          extensions.push(extension);
                      }
                  }
              }
              // if it's rooted, return it if exists. otherwise return empty.
              if (ioUtil.isRooted(tool)) {
                  const filePath = yield ioUtil.tryGetExecutablePath(tool, extensions);
                  if (filePath) {
                      return filePath;
                  }
                  return '';
              }
              // if any path separators, return empty
              if (tool.includes('/') || (ioUtil.IS_WINDOWS && tool.includes('\\'))) {
                  return '';
              }
              // build the list of directories
              //
              // Note, technically "where" checks the current directory on Windows. From a toolkit perspective,
              // it feels like we should not do this. Checking the current directory seems like more of a use
              // case of a shell, and the which() function exposed by the toolkit should strive for consistency
              // across platforms.
              const directories = [];
              if (process.env.PATH) {
                  for (const p of process.env.PATH.split(path.delimiter)) {
                      if (p) {
                          directories.push(p);
                      }
                  }
              }
              // return the first match
              for (const directory of directories) {
                  const filePath = yield ioUtil.tryGetExecutablePath(directory + path.sep + tool, extensions);
                  if (filePath) {
                      return filePath;
                  }
              }
              return '';
          }
          catch (err) {
              throw new Error(`which failed with message ${err.message}`);
          }
      });
  }
  exports.which = which;
  function readCopyOptions(options) {
      const force = options.force == null ? true : options.force;
      const recursive = Boolean(options.recursive);
      return { force, recursive };
  }
  function cpDirRecursive(sourceDir, destDir, currentDepth, force) {
      return __awaiter(this, void 0, void 0, function* () {
          // Ensure there is not a run away recursive copy
          if (currentDepth >= 255)
              return;
          currentDepth++;
          yield mkdirP(destDir);
          const files = yield ioUtil.readdir(sourceDir);
          for (const fileName of files) {
              const srcFile = `${sourceDir}/${fileName}`;
              const destFile = `${destDir}/${fileName}`;
              const srcFileStat = yield ioUtil.lstat(srcFile);
              if (srcFileStat.isDirectory()) {
                  // Recurse
                  yield cpDirRecursive(srcFile, destFile, currentDepth, force);
              }
              else {
                  yield copyFile(srcFile, destFile, force);
              }
          }
          // Change the mode for the newly created directory
          yield ioUtil.chmod(destDir, (yield ioUtil.stat(sourceDir)).mode);
      });
  }
  // Buffered file copy
  function copyFile(srcFile, destFile, force) {
      return __awaiter(this, void 0, void 0, function* () {
          if ((yield ioUtil.lstat(srcFile)).isSymbolicLink()) {
              // unlink/re-link it
              try {
                  yield ioUtil.lstat(destFile);
                  yield ioUtil.unlink(destFile);
              }
              catch (e) {
                  // Try to override file permission
                  if (e.code === 'EPERM') {
                      yield ioUtil.chmod(destFile, '0666');
                      yield ioUtil.unlink(destFile);
                  }
                  // other errors = it doesn't exist, no work to do
              }
              // Copy over symlink
              const symlinkFull = yield ioUtil.readlink(srcFile);
              yield ioUtil.symlink(symlinkFull, destFile, ioUtil.IS_WINDOWS ? 'junction' : null);
          }
          else if (!(yield ioUtil.exists(destFile)) || force) {
              yield ioUtil.copyFile(srcFile, destFile);
          }
      });
  }
  //# sourceMappingURL=io.js.map
  
  /***/ }),
  
  /***/ 467:
  /***/ ((module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  
  function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
  
  var Stream = _interopDefault(__nccwpck_require__(2413));
  var http = _interopDefault(__nccwpck_require__(8605));
  var Url = _interopDefault(__nccwpck_require__(8835));
  var https = _interopDefault(__nccwpck_require__(7211));
  var zlib = _interopDefault(__nccwpck_require__(8761));
  
  // Based on https://github.com/tmpvar/jsdom/blob/aa85b2abf07766ff7bf5c1f6daafb3726f2f2db5/lib/jsdom/living/blob.js
  
  // fix for "Readable" isn't a named export issue
  const Readable = Stream.Readable;
  
  const BUFFER = Symbol('buffer');
  const TYPE = Symbol('type');
  
  class Blob {
  	constructor() {
  		this[TYPE] = '';
  
  		const blobParts = arguments[0];
  		const options = arguments[1];
  
  		const buffers = [];
  		let size = 0;
  
  		if (blobParts) {
  			const a = blobParts;
  			const length = Number(a.length);
  			for (let i = 0; i < length; i++) {
  				const element = a[i];
  				let buffer;
  				if (element instanceof Buffer) {
  					buffer = element;
  				} else if (ArrayBuffer.isView(element)) {
  					buffer = Buffer.from(element.buffer, element.byteOffset, element.byteLength);
  				} else if (element instanceof ArrayBuffer) {
  					buffer = Buffer.from(element);
  				} else if (element instanceof Blob) {
  					buffer = element[BUFFER];
  				} else {
  					buffer = Buffer.from(typeof element === 'string' ? element : String(element));
  				}
  				size += buffer.length;
  				buffers.push(buffer);
  			}
  		}
  
  		this[BUFFER] = Buffer.concat(buffers);
  
  		let type = options && options.type !== undefined && String(options.type).toLowerCase();
  		if (type && !/[^\u0020-\u007E]/.test(type)) {
  			this[TYPE] = type;
  		}
  	}
  	get size() {
  		return this[BUFFER].length;
  	}
  	get type() {
  		return this[TYPE];
  	}
  	text() {
  		return Promise.resolve(this[BUFFER].toString());
  	}
  	arrayBuffer() {
  		const buf = this[BUFFER];
  		const ab = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
  		return Promise.resolve(ab);
  	}
  	stream() {
  		const readable = new Readable();
  		readable._read = function () {};
  		readable.push(this[BUFFER]);
  		readable.push(null);
  		return readable;
  	}
  	toString() {
  		return '[object Blob]';
  	}
  	slice() {
  		const size = this.size;
  
  		const start = arguments[0];
  		const end = arguments[1];
  		let relativeStart, relativeEnd;
  		if (start === undefined) {
  			relativeStart = 0;
  		} else if (start < 0) {
  			relativeStart = Math.max(size + start, 0);
  		} else {
  			relativeStart = Math.min(start, size);
  		}
  		if (end === undefined) {
  			relativeEnd = size;
  		} else if (end < 0) {
  			relativeEnd = Math.max(size + end, 0);
  		} else {
  			relativeEnd = Math.min(end, size);
  		}
  		const span = Math.max(relativeEnd - relativeStart, 0);
  
  		const buffer = this[BUFFER];
  		const slicedBuffer = buffer.slice(relativeStart, relativeStart + span);
  		const blob = new Blob([], { type: arguments[2] });
  		blob[BUFFER] = slicedBuffer;
  		return blob;
  	}
  }
  
  Object.defineProperties(Blob.prototype, {
  	size: { enumerable: true },
  	type: { enumerable: true },
  	slice: { enumerable: true }
  });
  
  Object.defineProperty(Blob.prototype, Symbol.toStringTag, {
  	value: 'Blob',
  	writable: false,
  	enumerable: false,
  	configurable: true
  });
  
  /**
   * fetch-error.js
   *
   * FetchError interface for operational errors
   */
  
  /**
   * Create FetchError instance
   *
   * @param   String      message      Error message for human
   * @param   String      type         Error type for machine
   * @param   String      systemError  For Node.js system error
   * @return  FetchError
   */
  function FetchError(message, type, systemError) {
    Error.call(this, message);
  
    this.message = message;
    this.type = type;
  
    // when err.type is `system`, err.code contains system error code
    if (systemError) {
      this.code = this.errno = systemError.code;
    }
  
    // hide custom error implementation details from end-users
    Error.captureStackTrace(this, this.constructor);
  }
  
  FetchError.prototype = Object.create(Error.prototype);
  FetchError.prototype.constructor = FetchError;
  FetchError.prototype.name = 'FetchError';
  
  let convert;
  try {
  	convert = __nccwpck_require__(2877).convert;
  } catch (e) {}
  
  const INTERNALS = Symbol('Body internals');
  
  // fix an issue where "PassThrough" isn't a named export for node <10
  const PassThrough = Stream.PassThrough;
  
  /**
   * Body mixin
   *
   * Ref: https://fetch.spec.whatwg.org/#body
   *
   * @param   Stream  body  Readable stream
   * @param   Object  opts  Response options
   * @return  Void
   */
  function Body(body) {
  	var _this = this;
  
  	var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
  	    _ref$size = _ref.size;
  
  	let size = _ref$size === undefined ? 0 : _ref$size;
  	var _ref$timeout = _ref.timeout;
  	let timeout = _ref$timeout === undefined ? 0 : _ref$timeout;
  
  	if (body == null) {
  		// body is undefined or null
  		body = null;
  	} else if (isURLSearchParams(body)) {
  		// body is a URLSearchParams
  		body = Buffer.from(body.toString());
  	} else if (isBlob(body)) ; else if (Buffer.isBuffer(body)) ; else if (Object.prototype.toString.call(body) === '[object ArrayBuffer]') {
  		// body is ArrayBuffer
  		body = Buffer.from(body);
  	} else if (ArrayBuffer.isView(body)) {
  		// body is ArrayBufferView
  		body = Buffer.from(body.buffer, body.byteOffset, body.byteLength);
  	} else if (body instanceof Stream) ; else {
  		// none of the above
  		// coerce to string then buffer
  		body = Buffer.from(String(body));
  	}
  	this[INTERNALS] = {
  		body,
  		disturbed: false,
  		error: null
  	};
  	this.size = size;
  	this.timeout = timeout;
  
  	if (body instanceof Stream) {
  		body.on('error', function (err) {
  			const error = err.name === 'AbortError' ? err : new FetchError(`Invalid response body while trying to fetch ${_this.url}: ${err.message}`, 'system', err);
  			_this[INTERNALS].error = error;
  		});
  	}
  }
  
  Body.prototype = {
  	get body() {
  		return this[INTERNALS].body;
  	},
  
  	get bodyUsed() {
  		return this[INTERNALS].disturbed;
  	},
  
  	/**
    * Decode response as ArrayBuffer
    *
    * @return  Promise
    */
  	arrayBuffer() {
  		return consumeBody.call(this).then(function (buf) {
  			return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
  		});
  	},
  
  	/**
    * Return raw response as Blob
    *
    * @return Promise
    */
  	blob() {
  		let ct = this.headers && this.headers.get('content-type') || '';
  		return consumeBody.call(this).then(function (buf) {
  			return Object.assign(
  			// Prevent copying
  			new Blob([], {
  				type: ct.toLowerCase()
  			}), {
  				[BUFFER]: buf
  			});
  		});
  	},
  
  	/**
    * Decode response as json
    *
    * @return  Promise
    */
  	json() {
  		var _this2 = this;
  
  		return consumeBody.call(this).then(function (buffer) {
  			try {
  				return JSON.parse(buffer.toString());
  			} catch (err) {
  				return Body.Promise.reject(new FetchError(`invalid json response body at ${_this2.url} reason: ${err.message}`, 'invalid-json'));
  			}
  		});
  	},
  
  	/**
    * Decode response as text
    *
    * @return  Promise
    */
  	text() {
  		return consumeBody.call(this).then(function (buffer) {
  			return buffer.toString();
  		});
  	},
  
  	/**
    * Decode response as buffer (non-spec api)
    *
    * @return  Promise
    */
  	buffer() {
  		return consumeBody.call(this);
  	},
  
  	/**
    * Decode response as text, while automatically detecting the encoding and
    * trying to decode to UTF-8 (non-spec api)
    *
    * @return  Promise
    */
  	textConverted() {
  		var _this3 = this;
  
  		return consumeBody.call(this).then(function (buffer) {
  			return convertBody(buffer, _this3.headers);
  		});
  	}
  };
  
  // In browsers, all properties are enumerable.
  Object.defineProperties(Body.prototype, {
  	body: { enumerable: true },
  	bodyUsed: { enumerable: true },
  	arrayBuffer: { enumerable: true },
  	blob: { enumerable: true },
  	json: { enumerable: true },
  	text: { enumerable: true }
  });
  
  Body.mixIn = function (proto) {
  	for (const name of Object.getOwnPropertyNames(Body.prototype)) {
  		// istanbul ignore else: future proof
  		if (!(name in proto)) {
  			const desc = Object.getOwnPropertyDescriptor(Body.prototype, name);
  			Object.defineProperty(proto, name, desc);
  		}
  	}
  };
  
  /**
   * Consume and convert an entire Body to a Buffer.
   *
   * Ref: https://fetch.spec.whatwg.org/#concept-body-consume-body
   *
   * @return  Promise
   */
  function consumeBody() {
  	var _this4 = this;
  
  	if (this[INTERNALS].disturbed) {
  		return Body.Promise.reject(new TypeError(`body used already for: ${this.url}`));
  	}
  
  	this[INTERNALS].disturbed = true;
  
  	if (this[INTERNALS].error) {
  		return Body.Promise.reject(this[INTERNALS].error);
  	}
  
  	let body = this.body;
  
  	// body is null
  	if (body === null) {
  		return Body.Promise.resolve(Buffer.alloc(0));
  	}
  
  	// body is blob
  	if (isBlob(body)) {
  		body = body.stream();
  	}
  
  	// body is buffer
  	if (Buffer.isBuffer(body)) {
  		return Body.Promise.resolve(body);
  	}
  
  	// istanbul ignore if: should never happen
  	if (!(body instanceof Stream)) {
  		return Body.Promise.resolve(Buffer.alloc(0));
  	}
  
  	// body is stream
  	// get ready to actually consume the body
  	let accum = [];
  	let accumBytes = 0;
  	let abort = false;
  
  	return new Body.Promise(function (resolve, reject) {
  		let resTimeout;
  
  		// allow timeout on slow response body
  		if (_this4.timeout) {
  			resTimeout = setTimeout(function () {
  				abort = true;
  				reject(new FetchError(`Response timeout while trying to fetch ${_this4.url} (over ${_this4.timeout}ms)`, 'body-timeout'));
  			}, _this4.timeout);
  		}
  
  		// handle stream errors
  		body.on('error', function (err) {
  			if (err.name === 'AbortError') {
  				// if the request was aborted, reject with this Error
  				abort = true;
  				reject(err);
  			} else {
  				// other errors, such as incorrect content-encoding
  				reject(new FetchError(`Invalid response body while trying to fetch ${_this4.url}: ${err.message}`, 'system', err));
  			}
  		});
  
  		body.on('data', function (chunk) {
  			if (abort || chunk === null) {
  				return;
  			}
  
  			if (_this4.size && accumBytes + chunk.length > _this4.size) {
  				abort = true;
  				reject(new FetchError(`content size at ${_this4.url} over limit: ${_this4.size}`, 'max-size'));
  				return;
  			}
  
  			accumBytes += chunk.length;
  			accum.push(chunk);
  		});
  
  		body.on('end', function () {
  			if (abort) {
  				return;
  			}
  
  			clearTimeout(resTimeout);
  
  			try {
  				resolve(Buffer.concat(accum, accumBytes));
  			} catch (err) {
  				// handle streams that have accumulated too much data (issue #414)
  				reject(new FetchError(`Could not create Buffer from response body for ${_this4.url}: ${err.message}`, 'system', err));
  			}
  		});
  	});
  }
  
  /**
   * Detect buffer encoding and convert to target encoding
   * ref: http://www.w3.org/TR/2011/WD-html5-20110113/parsing.html#determining-the-character-encoding
   *
   * @param   Buffer  buffer    Incoming buffer
   * @param   String  encoding  Target encoding
   * @return  String
   */
  function convertBody(buffer, headers) {
  	if (typeof convert !== 'function') {
  		throw new Error('The package `encoding` must be installed to use the textConverted() function');
  	}
  
  	const ct = headers.get('content-type');
  	let charset = 'utf-8';
  	let res, str;
  
  	// header
  	if (ct) {
  		res = /charset=([^;]*)/i.exec(ct);
  	}
  
  	// no charset in content type, peek at response body for at most 1024 bytes
  	str = buffer.slice(0, 1024).toString();
  
  	// html5
  	if (!res && str) {
  		res = /<meta.+?charset=(['"])(.+?)\1/i.exec(str);
  	}
  
  	// html4
  	if (!res && str) {
  		res = /<meta[\s]+?http-equiv=(['"])content-type\1[\s]+?content=(['"])(.+?)\2/i.exec(str);
  		if (!res) {
  			res = /<meta[\s]+?content=(['"])(.+?)\1[\s]+?http-equiv=(['"])content-type\3/i.exec(str);
  			if (res) {
  				res.pop(); // drop last quote
  			}
  		}
  
  		if (res) {
  			res = /charset=(.*)/i.exec(res.pop());
  		}
  	}
  
  	// xml
  	if (!res && str) {
  		res = /<\?xml.+?encoding=(['"])(.+?)\1/i.exec(str);
  	}
  
  	// found charset
  	if (res) {
  		charset = res.pop();
  
  		// prevent decode issues when sites use incorrect encoding
  		// ref: https://hsivonen.fi/encoding-menu/
  		if (charset === 'gb2312' || charset === 'gbk') {
  			charset = 'gb18030';
  		}
  	}
  
  	// turn raw buffers into a single utf-8 buffer
  	return convert(buffer, 'UTF-8', charset).toString();
  }
  
  /**
   * Detect a URLSearchParams object
   * ref: https://github.com/bitinn/node-fetch/issues/296#issuecomment-307598143
   *
   * @param   Object  obj     Object to detect by type or brand
   * @return  String
   */
  function isURLSearchParams(obj) {
  	// Duck-typing as a necessary condition.
  	if (typeof obj !== 'object' || typeof obj.append !== 'function' || typeof obj.delete !== 'function' || typeof obj.get !== 'function' || typeof obj.getAll !== 'function' || typeof obj.has !== 'function' || typeof obj.set !== 'function') {
  		return false;
  	}
  
  	// Brand-checking and more duck-typing as optional condition.
  	return obj.constructor.name === 'URLSearchParams' || Object.prototype.toString.call(obj) === '[object URLSearchParams]' || typeof obj.sort === 'function';
  }
  
  /**
   * Check if `obj` is a W3C `Blob` object (which `File` inherits from)
   * @param  {*} obj
   * @return {boolean}
   */
  function isBlob(obj) {
  	return typeof obj === 'object' && typeof obj.arrayBuffer === 'function' && typeof obj.type === 'string' && typeof obj.stream === 'function' && typeof obj.constructor === 'function' && typeof obj.constructor.name === 'string' && /^(Blob|File)$/.test(obj.constructor.name) && /^(Blob|File)$/.test(obj[Symbol.toStringTag]);
  }
  
  /**
   * Clone body given Res/Req instance
   *
   * @param   Mixed  instance  Response or Request instance
   * @return  Mixed
   */
  function clone(instance) {
  	let p1, p2;
  	let body = instance.body;
  
  	// don't allow cloning a used body
  	if (instance.bodyUsed) {
  		throw new Error('cannot clone body after it is used');
  	}
  
  	// check that body is a stream and not form-data object
  	// note: we can't clone the form-data object without having it as a dependency
  	if (body instanceof Stream && typeof body.getBoundary !== 'function') {
  		// tee instance body
  		p1 = new PassThrough();
  		p2 = new PassThrough();
  		body.pipe(p1);
  		body.pipe(p2);
  		// set instance body to teed body and return the other teed body
  		instance[INTERNALS].body = p1;
  		body = p2;
  	}
  
  	return body;
  }
  
  /**
   * Performs the operation "extract a `Content-Type` value from |object|" as
   * specified in the specification:
   * https://fetch.spec.whatwg.org/#concept-bodyinit-extract
   *
   * This function assumes that instance.body is present.
   *
   * @param   Mixed  instance  Any options.body input
   */
  function extractContentType(body) {
  	if (body === null) {
  		// body is null
  		return null;
  	} else if (typeof body === 'string') {
  		// body is string
  		return 'text/plain;charset=UTF-8';
  	} else if (isURLSearchParams(body)) {
  		// body is a URLSearchParams
  		return 'application/x-www-form-urlencoded;charset=UTF-8';
  	} else if (isBlob(body)) {
  		// body is blob
  		return body.type || null;
  	} else if (Buffer.isBuffer(body)) {
  		// body is buffer
  		return null;
  	} else if (Object.prototype.toString.call(body) === '[object ArrayBuffer]') {
  		// body is ArrayBuffer
  		return null;
  	} else if (ArrayBuffer.isView(body)) {
  		// body is ArrayBufferView
  		return null;
  	} else if (typeof body.getBoundary === 'function') {
  		// detect form data input from form-data module
  		return `multipart/form-data;boundary=${body.getBoundary()}`;
  	} else if (body instanceof Stream) {
  		// body is stream
  		// can't really do much about this
  		return null;
  	} else {
  		// Body constructor defaults other things to string
  		return 'text/plain;charset=UTF-8';
  	}
  }
  
  /**
   * The Fetch Standard treats this as if "total bytes" is a property on the body.
   * For us, we have to explicitly get it with a function.
   *
   * ref: https://fetch.spec.whatwg.org/#concept-body-total-bytes
   *
   * @param   Body    instance   Instance of Body
   * @return  Number?            Number of bytes, or null if not possible
   */
  function getTotalBytes(instance) {
  	const body = instance.body;
  
  
  	if (body === null) {
  		// body is null
  		return 0;
  	} else if (isBlob(body)) {
  		return body.size;
  	} else if (Buffer.isBuffer(body)) {
  		// body is buffer
  		return body.length;
  	} else if (body && typeof body.getLengthSync === 'function') {
  		// detect form data input from form-data module
  		if (body._lengthRetrievers && body._lengthRetrievers.length == 0 || // 1.x
  		body.hasKnownLength && body.hasKnownLength()) {
  			// 2.x
  			return body.getLengthSync();
  		}
  		return null;
  	} else {
  		// body is stream
  		return null;
  	}
  }
  
  /**
   * Write a Body to a Node.js WritableStream (e.g. http.Request) object.
   *
   * @param   Body    instance   Instance of Body
   * @return  Void
   */
  function writeToStream(dest, instance) {
  	const body = instance.body;
  
  
  	if (body === null) {
  		// body is null
  		dest.end();
  	} else if (isBlob(body)) {
  		body.stream().pipe(dest);
  	} else if (Buffer.isBuffer(body)) {
  		// body is buffer
  		dest.write(body);
  		dest.end();
  	} else {
  		// body is stream
  		body.pipe(dest);
  	}
  }
  
  // expose Promise
  Body.Promise = global.Promise;
  
  /**
   * headers.js
   *
   * Headers class offers convenient helpers
   */
  
  const invalidTokenRegex = /[^\^_`a-zA-Z\-0-9!#$%&'*+.|~]/;
  const invalidHeaderCharRegex = /[^\t\x20-\x7e\x80-\xff]/;
  
  function validateName(name) {
  	name = `${name}`;
  	if (invalidTokenRegex.test(name) || name === '') {
  		throw new TypeError(`${name} is not a legal HTTP header name`);
  	}
  }
  
  function validateValue(value) {
  	value = `${value}`;
  	if (invalidHeaderCharRegex.test(value)) {
  		throw new TypeError(`${value} is not a legal HTTP header value`);
  	}
  }
  
  /**
   * Find the key in the map object given a header name.
   *
   * Returns undefined if not found.
   *
   * @param   String  name  Header name
   * @return  String|Undefined
   */
  function find(map, name) {
  	name = name.toLowerCase();
  	for (const key in map) {
  		if (key.toLowerCase() === name) {
  			return key;
  		}
  	}
  	return undefined;
  }
  
  const MAP = Symbol('map');
  class Headers {
  	/**
    * Headers class
    *
    * @param   Object  headers  Response headers
    * @return  Void
    */
  	constructor() {
  		let init = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
  
  		this[MAP] = Object.create(null);
  
  		if (init instanceof Headers) {
  			const rawHeaders = init.raw();
  			const headerNames = Object.keys(rawHeaders);
  
  			for (const headerName of headerNames) {
  				for (const value of rawHeaders[headerName]) {
  					this.append(headerName, value);
  				}
  			}
  
  			return;
  		}
  
  		// We don't worry about converting prop to ByteString here as append()
  		// will handle it.
  		if (init == null) ; else if (typeof init === 'object') {
  			const method = init[Symbol.iterator];
  			if (method != null) {
  				if (typeof method !== 'function') {
  					throw new TypeError('Header pairs must be iterable');
  				}
  
  				// sequence<sequence<ByteString>>
  				// Note: per spec we have to first exhaust the lists then process them
  				const pairs = [];
  				for (const pair of init) {
  					if (typeof pair !== 'object' || typeof pair[Symbol.iterator] !== 'function') {
  						throw new TypeError('Each header pair must be iterable');
  					}
  					pairs.push(Array.from(pair));
  				}
  
  				for (const pair of pairs) {
  					if (pair.length !== 2) {
  						throw new TypeError('Each header pair must be a name/value tuple');
  					}
  					this.append(pair[0], pair[1]);
  				}
  			} else {
  				// record<ByteString, ByteString>
  				for (const key of Object.keys(init)) {
  					const value = init[key];
  					this.append(key, value);
  				}
  			}
  		} else {
  			throw new TypeError('Provided initializer must be an object');
  		}
  	}
  
  	/**
    * Return combined header value given name
    *
    * @param   String  name  Header name
    * @return  Mixed
    */
  	get(name) {
  		name = `${name}`;
  		validateName(name);
  		const key = find(this[MAP], name);
  		if (key === undefined) {
  			return null;
  		}
  
  		return this[MAP][key].join(', ');
  	}
  
  	/**
    * Iterate over all headers
    *
    * @param   Function  callback  Executed for each item with parameters (value, name, thisArg)
    * @param   Boolean   thisArg   `this` context for callback function
    * @return  Void
    */
  	forEach(callback) {
  		let thisArg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
  
  		let pairs = getHeaders(this);
  		let i = 0;
  		while (i < pairs.length) {
  			var _pairs$i = pairs[i];
  			const name = _pairs$i[0],
  			      value = _pairs$i[1];
  
  			callback.call(thisArg, value, name, this);
  			pairs = getHeaders(this);
  			i++;
  		}
  	}
  
  	/**
    * Overwrite header values given name
    *
    * @param   String  name   Header name
    * @param   String  value  Header value
    * @return  Void
    */
  	set(name, value) {
  		name = `${name}`;
  		value = `${value}`;
  		validateName(name);
  		validateValue(value);
  		const key = find(this[MAP], name);
  		this[MAP][key !== undefined ? key : name] = [value];
  	}
  
  	/**
    * Append a value onto existing header
    *
    * @param   String  name   Header name
    * @param   String  value  Header value
    * @return  Void
    */
  	append(name, value) {
  		name = `${name}`;
  		value = `${value}`;
  		validateName(name);
  		validateValue(value);
  		const key = find(this[MAP], name);
  		if (key !== undefined) {
  			this[MAP][key].push(value);
  		} else {
  			this[MAP][name] = [value];
  		}
  	}
  
  	/**
    * Check for header name existence
    *
    * @param   String   name  Header name
    * @return  Boolean
    */
  	has(name) {
  		name = `${name}`;
  		validateName(name);
  		return find(this[MAP], name) !== undefined;
  	}
  
  	/**
    * Delete all header values given name
    *
    * @param   String  name  Header name
    * @return  Void
    */
  	delete(name) {
  		name = `${name}`;
  		validateName(name);
  		const key = find(this[MAP], name);
  		if (key !== undefined) {
  			delete this[MAP][key];
  		}
  	}
  
  	/**
    * Return raw headers (non-spec api)
    *
    * @return  Object
    */
  	raw() {
  		return this[MAP];
  	}
  
  	/**
    * Get an iterator on keys.
    *
    * @return  Iterator
    */
  	keys() {
  		return createHeadersIterator(this, 'key');
  	}
  
  	/**
    * Get an iterator on values.
    *
    * @return  Iterator
    */
  	values() {
  		return createHeadersIterator(this, 'value');
  	}
  
  	/**
    * Get an iterator on entries.
    *
    * This is the default iterator of the Headers object.
    *
    * @return  Iterator
    */
  	[Symbol.iterator]() {
  		return createHeadersIterator(this, 'key+value');
  	}
  }
  Headers.prototype.entries = Headers.prototype[Symbol.iterator];
  
  Object.defineProperty(Headers.prototype, Symbol.toStringTag, {
  	value: 'Headers',
  	writable: false,
  	enumerable: false,
  	configurable: true
  });
  
  Object.defineProperties(Headers.prototype, {
  	get: { enumerable: true },
  	forEach: { enumerable: true },
  	set: { enumerable: true },
  	append: { enumerable: true },
  	has: { enumerable: true },
  	delete: { enumerable: true },
  	keys: { enumerable: true },
  	values: { enumerable: true },
  	entries: { enumerable: true }
  });
  
  function getHeaders(headers) {
  	let kind = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'key+value';
  
  	const keys = Object.keys(headers[MAP]).sort();
  	return keys.map(kind === 'key' ? function (k) {
  		return k.toLowerCase();
  	} : kind === 'value' ? function (k) {
  		return headers[MAP][k].join(', ');
  	} : function (k) {
  		return [k.toLowerCase(), headers[MAP][k].join(', ')];
  	});
  }
  
  const INTERNAL = Symbol('internal');
  
  function createHeadersIterator(target, kind) {
  	const iterator = Object.create(HeadersIteratorPrototype);
  	iterator[INTERNAL] = {
  		target,
  		kind,
  		index: 0
  	};
  	return iterator;
  }
  
  const HeadersIteratorPrototype = Object.setPrototypeOf({
  	next() {
  		// istanbul ignore if
  		if (!this || Object.getPrototypeOf(this) !== HeadersIteratorPrototype) {
  			throw new TypeError('Value of `this` is not a HeadersIterator');
  		}
  
  		var _INTERNAL = this[INTERNAL];
  		const target = _INTERNAL.target,
  		      kind = _INTERNAL.kind,
  		      index = _INTERNAL.index;
  
  		const values = getHeaders(target, kind);
  		const len = values.length;
  		if (index >= len) {
  			return {
  				value: undefined,
  				done: true
  			};
  		}
  
  		this[INTERNAL].index = index + 1;
  
  		return {
  			value: values[index],
  			done: false
  		};
  	}
  }, Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]())));
  
  Object.defineProperty(HeadersIteratorPrototype, Symbol.toStringTag, {
  	value: 'HeadersIterator',
  	writable: false,
  	enumerable: false,
  	configurable: true
  });
  
  /**
   * Export the Headers object in a form that Node.js can consume.
   *
   * @param   Headers  headers
   * @return  Object
   */
  function exportNodeCompatibleHeaders(headers) {
  	const obj = Object.assign({ __proto__: null }, headers[MAP]);
  
  	// http.request() only supports string as Host header. This hack makes
  	// specifying custom Host header possible.
  	const hostHeaderKey = find(headers[MAP], 'Host');
  	if (hostHeaderKey !== undefined) {
  		obj[hostHeaderKey] = obj[hostHeaderKey][0];
  	}
  
  	return obj;
  }
  
  /**
   * Create a Headers object from an object of headers, ignoring those that do
   * not conform to HTTP grammar productions.
   *
   * @param   Object  obj  Object of headers
   * @return  Headers
   */
  function createHeadersLenient(obj) {
  	const headers = new Headers();
  	for (const name of Object.keys(obj)) {
  		if (invalidTokenRegex.test(name)) {
  			continue;
  		}
  		if (Array.isArray(obj[name])) {
  			for (const val of obj[name]) {
  				if (invalidHeaderCharRegex.test(val)) {
  					continue;
  				}
  				if (headers[MAP][name] === undefined) {
  					headers[MAP][name] = [val];
  				} else {
  					headers[MAP][name].push(val);
  				}
  			}
  		} else if (!invalidHeaderCharRegex.test(obj[name])) {
  			headers[MAP][name] = [obj[name]];
  		}
  	}
  	return headers;
  }
  
  const INTERNALS$1 = Symbol('Response internals');
  
  // fix an issue where "STATUS_CODES" aren't a named export for node <10
  const STATUS_CODES = http.STATUS_CODES;
  
  /**
   * Response class
   *
   * @param   Stream  body  Readable stream
   * @param   Object  opts  Response options
   * @return  Void
   */
  class Response {
  	constructor() {
  		let body = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
  		let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  
  		Body.call(this, body, opts);
  
  		const status = opts.status || 200;
  		const headers = new Headers(opts.headers);
  
  		if (body != null && !headers.has('Content-Type')) {
  			const contentType = extractContentType(body);
  			if (contentType) {
  				headers.append('Content-Type', contentType);
  			}
  		}
  
  		this[INTERNALS$1] = {
  			url: opts.url,
  			status,
  			statusText: opts.statusText || STATUS_CODES[status],
  			headers,
  			counter: opts.counter
  		};
  	}
  
  	get url() {
  		return this[INTERNALS$1].url || '';
  	}
  
  	get status() {
  		return this[INTERNALS$1].status;
  	}
  
  	/**
    * Convenience property representing if the request ended normally
    */
  	get ok() {
  		return this[INTERNALS$1].status >= 200 && this[INTERNALS$1].status < 300;
  	}
  
  	get redirected() {
  		return this[INTERNALS$1].counter > 0;
  	}
  
  	get statusText() {
  		return this[INTERNALS$1].statusText;
  	}
  
  	get headers() {
  		return this[INTERNALS$1].headers;
  	}
  
  	/**
    * Clone this response
    *
    * @return  Response
    */
  	clone() {
  		return new Response(clone(this), {
  			url: this.url,
  			status: this.status,
  			statusText: this.statusText,
  			headers: this.headers,
  			ok: this.ok,
  			redirected: this.redirected
  		});
  	}
  }
  
  Body.mixIn(Response.prototype);
  
  Object.defineProperties(Response.prototype, {
  	url: { enumerable: true },
  	status: { enumerable: true },
  	ok: { enumerable: true },
  	redirected: { enumerable: true },
  	statusText: { enumerable: true },
  	headers: { enumerable: true },
  	clone: { enumerable: true }
  });
  
  Object.defineProperty(Response.prototype, Symbol.toStringTag, {
  	value: 'Response',
  	writable: false,
  	enumerable: false,
  	configurable: true
  });
  
  const INTERNALS$2 = Symbol('Request internals');
  
  // fix an issue where "format", "parse" aren't a named export for node <10
  const parse_url = Url.parse;
  const format_url = Url.format;
  
  const streamDestructionSupported = 'destroy' in Stream.Readable.prototype;
  
  /**
   * Check if a value is an instance of Request.
   *
   * @param   Mixed   input
   * @return  Boolean
   */
  function isRequest(input) {
  	return typeof input === 'object' && typeof input[INTERNALS$2] === 'object';
  }
  
  function isAbortSignal(signal) {
  	const proto = signal && typeof signal === 'object' && Object.getPrototypeOf(signal);
  	return !!(proto && proto.constructor.name === 'AbortSignal');
  }
  
  /**
   * Request class
   *
   * @param   Mixed   input  Url or Request instance
   * @param   Object  init   Custom options
   * @return  Void
   */
  class Request {
  	constructor(input) {
  		let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  
  		let parsedURL;
  
  		// normalize input
  		if (!isRequest(input)) {
  			if (input && input.href) {
  				// in order to support Node.js' Url objects; though WHATWG's URL objects
  				// will fall into this branch also (since their `toString()` will return
  				// `href` property anyway)
  				parsedURL = parse_url(input.href);
  			} else {
  				// coerce input to a string before attempting to parse
  				parsedURL = parse_url(`${input}`);
  			}
  			input = {};
  		} else {
  			parsedURL = parse_url(input.url);
  		}
  
  		let method = init.method || input.method || 'GET';
  		method = method.toUpperCase();
  
  		if ((init.body != null || isRequest(input) && input.body !== null) && (method === 'GET' || method === 'HEAD')) {
  			throw new TypeError('Request with GET/HEAD method cannot have body');
  		}
  
  		let inputBody = init.body != null ? init.body : isRequest(input) && input.body !== null ? clone(input) : null;
  
  		Body.call(this, inputBody, {
  			timeout: init.timeout || input.timeout || 0,
  			size: init.size || input.size || 0
  		});
  
  		const headers = new Headers(init.headers || input.headers || {});
  
  		if (inputBody != null && !headers.has('Content-Type')) {
  			const contentType = extractContentType(inputBody);
  			if (contentType) {
  				headers.append('Content-Type', contentType);
  			}
  		}
  
  		let signal = isRequest(input) ? input.signal : null;
  		if ('signal' in init) signal = init.signal;
  
  		if (signal != null && !isAbortSignal(signal)) {
  			throw new TypeError('Expected signal to be an instanceof AbortSignal');
  		}
  
  		this[INTERNALS$2] = {
  			method,
  			redirect: init.redirect || input.redirect || 'follow',
  			headers,
  			parsedURL,
  			signal
  		};
  
  		// node-fetch-only options
  		this.follow = init.follow !== undefined ? init.follow : input.follow !== undefined ? input.follow : 20;
  		this.compress = init.compress !== undefined ? init.compress : input.compress !== undefined ? input.compress : true;
  		this.counter = init.counter || input.counter || 0;
  		this.agent = init.agent || input.agent;
  	}
  
  	get method() {
  		return this[INTERNALS$2].method;
  	}
  
  	get url() {
  		return format_url(this[INTERNALS$2].parsedURL);
  	}
  
  	get headers() {
  		return this[INTERNALS$2].headers;
  	}
  
  	get redirect() {
  		return this[INTERNALS$2].redirect;
  	}
  
  	get signal() {
  		return this[INTERNALS$2].signal;
  	}
  
  	/**
    * Clone this request
    *
    * @return  Request
    */
  	clone() {
  		return new Request(this);
  	}
  }
  
  Body.mixIn(Request.prototype);
  
  Object.defineProperty(Request.prototype, Symbol.toStringTag, {
  	value: 'Request',
  	writable: false,
  	enumerable: false,
  	configurable: true
  });
  
  Object.defineProperties(Request.prototype, {
  	method: { enumerable: true },
  	url: { enumerable: true },
  	headers: { enumerable: true },
  	redirect: { enumerable: true },
  	clone: { enumerable: true },
  	signal: { enumerable: true }
  });
  
  /**
   * Convert a Request to Node.js http request options.
   *
   * @param   Request  A Request instance
   * @return  Object   The options object to be passed to http.request
   */
  function getNodeRequestOptions(request) {
  	const parsedURL = request[INTERNALS$2].parsedURL;
  	const headers = new Headers(request[INTERNALS$2].headers);
  
  	// fetch step 1.3
  	if (!headers.has('Accept')) {
  		headers.set('Accept', '*/*');
  	}
  
  	// Basic fetch
  	if (!parsedURL.protocol || !parsedURL.hostname) {
  		throw new TypeError('Only absolute URLs are supported');
  	}
  
  	if (!/^https?:$/.test(parsedURL.protocol)) {
  		throw new TypeError('Only HTTP(S) protocols are supported');
  	}
  
  	if (request.signal && request.body instanceof Stream.Readable && !streamDestructionSupported) {
  		throw new Error('Cancellation of streamed requests with AbortSignal is not supported in node < 8');
  	}
  
  	// HTTP-network-or-cache fetch steps 2.4-2.7
  	let contentLengthValue = null;
  	if (request.body == null && /^(POST|PUT)$/i.test(request.method)) {
  		contentLengthValue = '0';
  	}
  	if (request.body != null) {
  		const totalBytes = getTotalBytes(request);
  		if (typeof totalBytes === 'number') {
  			contentLengthValue = String(totalBytes);
  		}
  	}
  	if (contentLengthValue) {
  		headers.set('Content-Length', contentLengthValue);
  	}
  
  	// HTTP-network-or-cache fetch step 2.11
  	if (!headers.has('User-Agent')) {
  		headers.set('User-Agent', 'node-fetch/1.0 (+https://github.com/bitinn/node-fetch)');
  	}
  
  	// HTTP-network-or-cache fetch step 2.15
  	if (request.compress && !headers.has('Accept-Encoding')) {
  		headers.set('Accept-Encoding', 'gzip,deflate');
  	}
  
  	let agent = request.agent;
  	if (typeof agent === 'function') {
  		agent = agent(parsedURL);
  	}
  
  	if (!headers.has('Connection') && !agent) {
  		headers.set('Connection', 'close');
  	}
  
  	// HTTP-network fetch step 4.2
  	// chunked encoding is handled by Node.js
  
  	return Object.assign({}, parsedURL, {
  		method: request.method,
  		headers: exportNodeCompatibleHeaders(headers),
  		agent
  	});
  }
  
  /**
   * abort-error.js
   *
   * AbortError interface for cancelled requests
   */
  
  /**
   * Create AbortError instance
   *
   * @param   String      message      Error message for human
   * @return  AbortError
   */
  function AbortError(message) {
    Error.call(this, message);
  
    this.type = 'aborted';
    this.message = message;
  
    // hide custom error implementation details from end-users
    Error.captureStackTrace(this, this.constructor);
  }
  
  AbortError.prototype = Object.create(Error.prototype);
  AbortError.prototype.constructor = AbortError;
  AbortError.prototype.name = 'AbortError';
  
  // fix an issue where "PassThrough", "resolve" aren't a named export for node <10
  const PassThrough$1 = Stream.PassThrough;
  const resolve_url = Url.resolve;
  
  /**
   * Fetch function
   *
   * @param   Mixed    url   Absolute url or Request instance
   * @param   Object   opts  Fetch options
   * @return  Promise
   */
  function fetch(url, opts) {
  
  	// allow custom promise
  	if (!fetch.Promise) {
  		throw new Error('native promise missing, set fetch.Promise to your favorite alternative');
  	}
  
  	Body.Promise = fetch.Promise;
  
  	// wrap http.request into fetch
  	return new fetch.Promise(function (resolve, reject) {
  		// build request object
  		const request = new Request(url, opts);
  		const options = getNodeRequestOptions(request);
  
  		const send = (options.protocol === 'https:' ? https : http).request;
  		const signal = request.signal;
  
  		let response = null;
  
  		const abort = function abort() {
  			let error = new AbortError('The user aborted a request.');
  			reject(error);
  			if (request.body && request.body instanceof Stream.Readable) {
  				request.body.destroy(error);
  			}
  			if (!response || !response.body) return;
  			response.body.emit('error', error);
  		};
  
  		if (signal && signal.aborted) {
  			abort();
  			return;
  		}
  
  		const abortAndFinalize = function abortAndFinalize() {
  			abort();
  			finalize();
  		};
  
  		// send request
  		const req = send(options);
  		let reqTimeout;
  
  		if (signal) {
  			signal.addEventListener('abort', abortAndFinalize);
  		}
  
  		function finalize() {
  			req.abort();
  			if (signal) signal.removeEventListener('abort', abortAndFinalize);
  			clearTimeout(reqTimeout);
  		}
  
  		if (request.timeout) {
  			req.once('socket', function (socket) {
  				reqTimeout = setTimeout(function () {
  					reject(new FetchError(`network timeout at: ${request.url}`, 'request-timeout'));
  					finalize();
  				}, request.timeout);
  			});
  		}
  
  		req.on('error', function (err) {
  			reject(new FetchError(`request to ${request.url} failed, reason: ${err.message}`, 'system', err));
  			finalize();
  		});
  
  		req.on('response', function (res) {
  			clearTimeout(reqTimeout);
  
  			const headers = createHeadersLenient(res.headers);
  
  			// HTTP fetch step 5
  			if (fetch.isRedirect(res.statusCode)) {
  				// HTTP fetch step 5.2
  				const location = headers.get('Location');
  
  				// HTTP fetch step 5.3
  				const locationURL = location === null ? null : resolve_url(request.url, location);
  
  				// HTTP fetch step 5.5
  				switch (request.redirect) {
  					case 'error':
  						reject(new FetchError(`uri requested responds with a redirect, redirect mode is set to error: ${request.url}`, 'no-redirect'));
  						finalize();
  						return;
  					case 'manual':
  						// node-fetch-specific step: make manual redirect a bit easier to use by setting the Location header value to the resolved URL.
  						if (locationURL !== null) {
  							// handle corrupted header
  							try {
  								headers.set('Location', locationURL);
  							} catch (err) {
  								// istanbul ignore next: nodejs server prevent invalid response headers, we can't test this through normal request
  								reject(err);
  							}
  						}
  						break;
  					case 'follow':
  						// HTTP-redirect fetch step 2
  						if (locationURL === null) {
  							break;
  						}
  
  						// HTTP-redirect fetch step 5
  						if (request.counter >= request.follow) {
  							reject(new FetchError(`maximum redirect reached at: ${request.url}`, 'max-redirect'));
  							finalize();
  							return;
  						}
  
  						// HTTP-redirect fetch step 6 (counter increment)
  						// Create a new Request object.
  						const requestOpts = {
  							headers: new Headers(request.headers),
  							follow: request.follow,
  							counter: request.counter + 1,
  							agent: request.agent,
  							compress: request.compress,
  							method: request.method,
  							body: request.body,
  							signal: request.signal,
  							timeout: request.timeout,
  							size: request.size
  						};
  
  						// HTTP-redirect fetch step 9
  						if (res.statusCode !== 303 && request.body && getTotalBytes(request) === null) {
  							reject(new FetchError('Cannot follow redirect with body being a readable stream', 'unsupported-redirect'));
  							finalize();
  							return;
  						}
  
  						// HTTP-redirect fetch step 11
  						if (res.statusCode === 303 || (res.statusCode === 301 || res.statusCode === 302) && request.method === 'POST') {
  							requestOpts.method = 'GET';
  							requestOpts.body = undefined;
  							requestOpts.headers.delete('content-length');
  						}
  
  						// HTTP-redirect fetch step 15
  						resolve(fetch(new Request(locationURL, requestOpts)));
  						finalize();
  						return;
  				}
  			}
  
  			// prepare response
  			res.once('end', function () {
  				if (signal) signal.removeEventListener('abort', abortAndFinalize);
  			});
  			let body = res.pipe(new PassThrough$1());
  
  			const response_options = {
  				url: request.url,
  				status: res.statusCode,
  				statusText: res.statusMessage,
  				headers: headers,
  				size: request.size,
  				timeout: request.timeout,
  				counter: request.counter
  			};
  
  			// HTTP-network fetch step 12.1.1.3
  			const codings = headers.get('Content-Encoding');
  
  			// HTTP-network fetch step 12.1.1.4: handle content codings
  
  			// in following scenarios we ignore compression support
  			// 1. compression support is disabled
  			// 2. HEAD request
  			// 3. no Content-Encoding header
  			// 4. no content response (204)
  			// 5. content not modified response (304)
  			if (!request.compress || request.method === 'HEAD' || codings === null || res.statusCode === 204 || res.statusCode === 304) {
  				response = new Response(body, response_options);
  				resolve(response);
  				return;
  			}
  
  			// For Node v6+
  			// Be less strict when decoding compressed responses, since sometimes
  			// servers send slightly invalid responses that are still accepted
  			// by common browsers.
  			// Always using Z_SYNC_FLUSH is what cURL does.
  			const zlibOptions = {
  				flush: zlib.Z_SYNC_FLUSH,
  				finishFlush: zlib.Z_SYNC_FLUSH
  			};
  
  			// for gzip
  			if (codings == 'gzip' || codings == 'x-gzip') {
  				body = body.pipe(zlib.createGunzip(zlibOptions));
  				response = new Response(body, response_options);
  				resolve(response);
  				return;
  			}
  
  			// for deflate
  			if (codings == 'deflate' || codings == 'x-deflate') {
  				// handle the infamous raw deflate response from old servers
  				// a hack for old IIS and Apache servers
  				const raw = res.pipe(new PassThrough$1());
  				raw.once('data', function (chunk) {
  					// see http://stackoverflow.com/questions/37519828
  					if ((chunk[0] & 0x0F) === 0x08) {
  						body = body.pipe(zlib.createInflate());
  					} else {
  						body = body.pipe(zlib.createInflateRaw());
  					}
  					response = new Response(body, response_options);
  					resolve(response);
  				});
  				return;
  			}
  
  			// for br
  			if (codings == 'br' && typeof zlib.createBrotliDecompress === 'function') {
  				body = body.pipe(zlib.createBrotliDecompress());
  				response = new Response(body, response_options);
  				resolve(response);
  				return;
  			}
  
  			// otherwise, use response as-is
  			response = new Response(body, response_options);
  			resolve(response);
  		});
  
  		writeToStream(req, request);
  	});
  }
  /**
   * Redirect code matching
   *
   * @param   Number   code  Status code
   * @return  Boolean
   */
  fetch.isRedirect = function (code) {
  	return code === 301 || code === 302 || code === 303 || code === 307 || code === 308;
  };
  
  // expose Promise
  fetch.Promise = global.Promise;
  
  module.exports = exports = fetch;
  Object.defineProperty(exports, "__esModule", ({ value: true }));
  exports.default = exports;
  exports.Headers = Headers;
  exports.Request = Request;
  exports.Response = Response;
  exports.FetchError = FetchError;
  
  
  /***/ }),
  
  /***/ 2548:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  const retry = __nccwpck_require__(4347);
  
  const networkErrorMsgs = [
  	'Failed to fetch', // Chrome
  	'NetworkError when attempting to fetch resource', // Firefox
  	'The Internet connection appears to be offline' // Safari
  ];
  
  class AbortError extends Error {
  	constructor(message) {
  		super();
  
  		if (message instanceof Error) {
  			this.originalError = message;
  			({message} = message);
  		} else {
  			this.originalError = new Error(message);
  			this.originalError.stack = this.stack;
  		}
  
  		this.name = 'AbortError';
  		this.message = message;
  	}
  }
  
  const decorateErrorWithCounts = (error, attemptNumber, options) => {
  	// Minus 1 from attemptNumber because the first attempt does not count as a retry
  	const retriesLeft = options.retries - (attemptNumber - 1);
  
  	error.attemptNumber = attemptNumber;
  	error.retriesLeft = retriesLeft;
  	return error;
  };
  
  const isNetworkError = errorMessage => networkErrorMsgs.includes(errorMessage);
  
  const pRetry = (input, options) => new Promise((resolve, reject) => {
  	options = {
  		onFailedAttempt: () => {},
  		retries: 10,
  		...options
  	};
  
  	const operation = retry.operation(options);
  
  	operation.attempt(async attemptNumber => {
  		try {
  			resolve(await input(attemptNumber));
  		} catch (error) {
  			if (!(error instanceof Error)) {
  				reject(new TypeError(`Non-error was thrown: "${error}". You should only throw errors.`));
  				return;
  			}
  
  			if (error instanceof AbortError) {
  				operation.stop();
  				reject(error.originalError);
  			} else if (error instanceof TypeError && !isNetworkError(error.message)) {
  				operation.stop();
  				reject(error);
  			} else {
  				decorateErrorWithCounts(error, attemptNumber, options);
  
  				try {
  					await options.onFailedAttempt(error);
  				} catch (error) {
  					reject(error);
  					return;
  				}
  
  				if (!operation.retry(error)) {
  					reject(operation.mainError());
  				}
  			}
  		}
  	});
  });
  
  module.exports = pRetry;
  // TODO: remove this in the next major version
  module.exports.default = pRetry;
  
  module.exports.AbortError = AbortError;
  
  
  /***/ }),
  
  /***/ 4347:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  module.exports = __nccwpck_require__(6244);
  
  /***/ }),
  
  /***/ 6244:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  var RetryOperation = __nccwpck_require__(5369);
  
  exports.operation = function(options) {
    var timeouts = exports.timeouts(options);
    return new RetryOperation(timeouts, {
        forever: options && options.forever,
        unref: options && options.unref,
        maxRetryTime: options && options.maxRetryTime
    });
  };
  
  exports.timeouts = function(options) {
    if (options instanceof Array) {
      return [].concat(options);
    }
  
    var opts = {
      retries: 10,
      factor: 2,
      minTimeout: 1 * 1000,
      maxTimeout: Infinity,
      randomize: false
    };
    for (var key in options) {
      opts[key] = options[key];
    }
  
    if (opts.minTimeout > opts.maxTimeout) {
      throw new Error('minTimeout is greater than maxTimeout');
    }
  
    var timeouts = [];
    for (var i = 0; i < opts.retries; i++) {
      timeouts.push(this.createTimeout(i, opts));
    }
  
    if (options && options.forever && !timeouts.length) {
      timeouts.push(this.createTimeout(i, opts));
    }
  
    // sort the array numerically ascending
    timeouts.sort(function(a,b) {
      return a - b;
    });
  
    return timeouts;
  };
  
  exports.createTimeout = function(attempt, opts) {
    var random = (opts.randomize)
      ? (Math.random() + 1)
      : 1;
  
    var timeout = Math.round(random * opts.minTimeout * Math.pow(opts.factor, attempt));
    timeout = Math.min(timeout, opts.maxTimeout);
  
    return timeout;
  };
  
  exports.wrap = function(obj, options, methods) {
    if (options instanceof Array) {
      methods = options;
      options = null;
    }
  
    if (!methods) {
      methods = [];
      for (var key in obj) {
        if (typeof obj[key] === 'function') {
          methods.push(key);
        }
      }
    }
  
    for (var i = 0; i < methods.length; i++) {
      var method   = methods[i];
      var original = obj[method];
  
      obj[method] = function retryWrapper(original) {
        var op       = exports.operation(options);
        var args     = Array.prototype.slice.call(arguments, 1);
        var callback = args.pop();
  
        args.push(function(err) {
          if (op.retry(err)) {
            return;
          }
          if (err) {
            arguments[0] = op.mainError();
          }
          callback.apply(this, arguments);
        });
  
        op.attempt(function() {
          original.apply(obj, args);
        });
      }.bind(obj, original);
      obj[method].options = options;
    }
  };
  
  
  /***/ }),
  
  /***/ 5369:
  /***/ ((module) => {
  
  function RetryOperation(timeouts, options) {
    // Compatibility for the old (timeouts, retryForever) signature
    if (typeof options === 'boolean') {
      options = { forever: options };
    }
  
    this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
    this._timeouts = timeouts;
    this._options = options || {};
    this._maxRetryTime = options && options.maxRetryTime || Infinity;
    this._fn = null;
    this._errors = [];
    this._attempts = 1;
    this._operationTimeout = null;
    this._operationTimeoutCb = null;
    this._timeout = null;
    this._operationStart = null;
  
    if (this._options.forever) {
      this._cachedTimeouts = this._timeouts.slice(0);
    }
  }
  module.exports = RetryOperation;
  
  RetryOperation.prototype.reset = function() {
    this._attempts = 1;
    this._timeouts = this._originalTimeouts;
  }
  
  RetryOperation.prototype.stop = function() {
    if (this._timeout) {
      clearTimeout(this._timeout);
    }
  
    this._timeouts       = [];
    this._cachedTimeouts = null;
  };
  
  RetryOperation.prototype.retry = function(err) {
    if (this._timeout) {
      clearTimeout(this._timeout);
    }
  
    if (!err) {
      return false;
    }
    var currentTime = new Date().getTime();
    if (err && currentTime - this._operationStart >= this._maxRetryTime) {
      this._errors.unshift(new Error('RetryOperation timeout occurred'));
      return false;
    }
  
    this._errors.push(err);
  
    var timeout = this._timeouts.shift();
    if (timeout === undefined) {
      if (this._cachedTimeouts) {
        // retry forever, only keep last error
        this._errors.splice(this._errors.length - 1, this._errors.length);
        this._timeouts = this._cachedTimeouts.slice(0);
        timeout = this._timeouts.shift();
      } else {
        return false;
      }
    }
  
    var self = this;
    var timer = setTimeout(function() {
      self._attempts++;
  
      if (self._operationTimeoutCb) {
        self._timeout = setTimeout(function() {
          self._operationTimeoutCb(self._attempts);
        }, self._operationTimeout);
  
        if (self._options.unref) {
            self._timeout.unref();
        }
      }
  
      self._fn(self._attempts);
    }, timeout);
  
    if (this._options.unref) {
        timer.unref();
    }
  
    return true;
  };
  
  RetryOperation.prototype.attempt = function(fn, timeoutOps) {
    this._fn = fn;
  
    if (timeoutOps) {
      if (timeoutOps.timeout) {
        this._operationTimeout = timeoutOps.timeout;
      }
      if (timeoutOps.cb) {
        this._operationTimeoutCb = timeoutOps.cb;
      }
    }
  
    var self = this;
    if (this._operationTimeoutCb) {
      this._timeout = setTimeout(function() {
        self._operationTimeoutCb();
      }, self._operationTimeout);
    }
  
    this._operationStart = new Date().getTime();
  
    this._fn(this._attempts);
  };
  
  RetryOperation.prototype.try = function(fn) {
    console.log('Using RetryOperation.try() is deprecated');
    this.attempt(fn);
  };
  
  RetryOperation.prototype.start = function(fn) {
    console.log('Using RetryOperation.start() is deprecated');
    this.attempt(fn);
  };
  
  RetryOperation.prototype.start = RetryOperation.prototype.try;
  
  RetryOperation.prototype.errors = function() {
    return this._errors;
  };
  
  RetryOperation.prototype.attempts = function() {
    return this._attempts;
  };
  
  RetryOperation.prototype.mainError = function() {
    if (this._errors.length === 0) {
      return null;
    }
  
    var counts = {};
    var mainError = null;
    var mainErrorCount = 0;
  
    for (var i = 0; i < this._errors.length; i++) {
      var error = this._errors[i];
      var message = error.message;
      var count = (counts[message] || 0) + 1;
  
      counts[message] = count;
  
      if (count >= mainErrorCount) {
        mainError = error;
        mainErrorCount = count;
      }
    }
  
    return mainError;
  };
  
  
  /***/ }),
  
  /***/ 2043:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  ;(function (sax) { // wrapper for non-node envs
    sax.parser = function (strict, opt) { return new SAXParser(strict, opt) }
    sax.SAXParser = SAXParser
    sax.SAXStream = SAXStream
    sax.createStream = createStream
  
    // When we pass the MAX_BUFFER_LENGTH position, start checking for buffer overruns.
    // When we check, schedule the next check for MAX_BUFFER_LENGTH - (max(buffer lengths)),
    // since that's the earliest that a buffer overrun could occur.  This way, checks are
    // as rare as required, but as often as necessary to ensure never crossing this bound.
    // Furthermore, buffers are only tested at most once per write(), so passing a very
    // large string into write() might have undesirable effects, but this is manageable by
    // the caller, so it is assumed to be safe.  Thus, a call to write() may, in the extreme
    // edge case, result in creating at most one complete copy of the string passed in.
    // Set to Infinity to have unlimited buffers.
    sax.MAX_BUFFER_LENGTH = 64 * 1024
  
    var buffers = [
      'comment', 'sgmlDecl', 'textNode', 'tagName', 'doctype',
      'procInstName', 'procInstBody', 'entity', 'attribName',
      'attribValue', 'cdata', 'script'
    ]
  
    sax.EVENTS = [
      'text',
      'processinginstruction',
      'sgmldeclaration',
      'doctype',
      'comment',
      'opentagstart',
      'attribute',
      'opentag',
      'closetag',
      'opencdata',
      'cdata',
      'closecdata',
      'error',
      'end',
      'ready',
      'script',
      'opennamespace',
      'closenamespace'
    ]
  
    function SAXParser (strict, opt) {
      if (!(this instanceof SAXParser)) {
        return new SAXParser(strict, opt)
      }
  
      var parser = this
      clearBuffers(parser)
      parser.q = parser.c = ''
      parser.bufferCheckPosition = sax.MAX_BUFFER_LENGTH
      parser.opt = opt || {}
      parser.opt.lowercase = parser.opt.lowercase || parser.opt.lowercasetags
      parser.looseCase = parser.opt.lowercase ? 'toLowerCase' : 'toUpperCase'
      parser.tags = []
      parser.closed = parser.closedRoot = parser.sawRoot = false
      parser.tag = parser.error = null
      parser.strict = !!strict
      parser.noscript = !!(strict || parser.opt.noscript)
      parser.state = S.BEGIN
      parser.strictEntities = parser.opt.strictEntities
      parser.ENTITIES = parser.strictEntities ? Object.create(sax.XML_ENTITIES) : Object.create(sax.ENTITIES)
      parser.attribList = []
  
      // namespaces form a prototype chain.
      // it always points at the current tag,
      // which protos to its parent tag.
      if (parser.opt.xmlns) {
        parser.ns = Object.create(rootNS)
      }
  
      // mostly just for error reporting
      parser.trackPosition = parser.opt.position !== false
      if (parser.trackPosition) {
        parser.position = parser.line = parser.column = 0
      }
      emit(parser, 'onready')
    }
  
    if (!Object.create) {
      Object.create = function (o) {
        function F () {}
        F.prototype = o
        var newf = new F()
        return newf
      }
    }
  
    if (!Object.keys) {
      Object.keys = function (o) {
        var a = []
        for (var i in o) if (o.hasOwnProperty(i)) a.push(i)
        return a
      }
    }
  
    function checkBufferLength (parser) {
      var maxAllowed = Math.max(sax.MAX_BUFFER_LENGTH, 10)
      var maxActual = 0
      for (var i = 0, l = buffers.length; i < l; i++) {
        var len = parser[buffers[i]].length
        if (len > maxAllowed) {
          // Text/cdata nodes can get big, and since they're buffered,
          // we can get here under normal conditions.
          // Avoid issues by emitting the text node now,
          // so at least it won't get any bigger.
          switch (buffers[i]) {
            case 'textNode':
              closeText(parser)
              break
  
            case 'cdata':
              emitNode(parser, 'oncdata', parser.cdata)
              parser.cdata = ''
              break
  
            case 'script':
              emitNode(parser, 'onscript', parser.script)
              parser.script = ''
              break
  
            default:
              error(parser, 'Max buffer length exceeded: ' + buffers[i])
          }
        }
        maxActual = Math.max(maxActual, len)
      }
      // schedule the next check for the earliest possible buffer overrun.
      var m = sax.MAX_BUFFER_LENGTH - maxActual
      parser.bufferCheckPosition = m + parser.position
    }
  
    function clearBuffers (parser) {
      for (var i = 0, l = buffers.length; i < l; i++) {
        parser[buffers[i]] = ''
      }
    }
  
    function flushBuffers (parser) {
      closeText(parser)
      if (parser.cdata !== '') {
        emitNode(parser, 'oncdata', parser.cdata)
        parser.cdata = ''
      }
      if (parser.script !== '') {
        emitNode(parser, 'onscript', parser.script)
        parser.script = ''
      }
    }
  
    SAXParser.prototype = {
      end: function () { end(this) },
      write: write,
      resume: function () { this.error = null; return this },
      close: function () { return this.write(null) },
      flush: function () { flushBuffers(this) }
    }
  
    var Stream
    try {
      Stream = __nccwpck_require__(2413).Stream
    } catch (ex) {
      Stream = function () {}
    }
  
    var streamWraps = sax.EVENTS.filter(function (ev) {
      return ev !== 'error' && ev !== 'end'
    })
  
    function createStream (strict, opt) {
      return new SAXStream(strict, opt)
    }
  
    function SAXStream (strict, opt) {
      if (!(this instanceof SAXStream)) {
        return new SAXStream(strict, opt)
      }
  
      Stream.apply(this)
  
      this._parser = new SAXParser(strict, opt)
      this.writable = true
      this.readable = true
  
      var me = this
  
      this._parser.onend = function () {
        me.emit('end')
      }
  
      this._parser.onerror = function (er) {
        me.emit('error', er)
  
        // if didn't throw, then means error was handled.
        // go ahead and clear error, so we can write again.
        me._parser.error = null
      }
  
      this._decoder = null
  
      streamWraps.forEach(function (ev) {
        Object.defineProperty(me, 'on' + ev, {
          get: function () {
            return me._parser['on' + ev]
          },
          set: function (h) {
            if (!h) {
              me.removeAllListeners(ev)
              me._parser['on' + ev] = h
              return h
            }
            me.on(ev, h)
          },
          enumerable: true,
          configurable: false
        })
      })
    }
  
    SAXStream.prototype = Object.create(Stream.prototype, {
      constructor: {
        value: SAXStream
      }
    })
  
    SAXStream.prototype.write = function (data) {
      if (typeof Buffer === 'function' &&
        typeof Buffer.isBuffer === 'function' &&
        Buffer.isBuffer(data)) {
        if (!this._decoder) {
          var SD = __nccwpck_require__(4304).StringDecoder
          this._decoder = new SD('utf8')
        }
        data = this._decoder.write(data)
      }
  
      this._parser.write(data.toString())
      this.emit('data', data)
      return true
    }
  
    SAXStream.prototype.end = function (chunk) {
      if (chunk && chunk.length) {
        this.write(chunk)
      }
      this._parser.end()
      return true
    }
  
    SAXStream.prototype.on = function (ev, handler) {
      var me = this
      if (!me._parser['on' + ev] && streamWraps.indexOf(ev) !== -1) {
        me._parser['on' + ev] = function () {
          var args = arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments)
          args.splice(0, 0, ev)
          me.emit.apply(me, args)
        }
      }
  
      return Stream.prototype.on.call(me, ev, handler)
    }
  
    // this really needs to be replaced with character classes.
    // XML allows all manner of ridiculous numbers and digits.
    var CDATA = '[CDATA['
    var DOCTYPE = 'DOCTYPE'
    var XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace'
    var XMLNS_NAMESPACE = 'http://www.w3.org/2000/xmlns/'
    var rootNS = { xml: XML_NAMESPACE, xmlns: XMLNS_NAMESPACE }
  
    // http://www.w3.org/TR/REC-xml/#NT-NameStartChar
    // This implementation works on strings, a single character at a time
    // as such, it cannot ever support astral-plane characters (10000-EFFFF)
    // without a significant breaking change to either this  parser, or the
    // JavaScript language.  Implementation of an emoji-capable xml parser
    // is left as an exercise for the reader.
    var nameStart = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/
  
    var nameBody = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/
  
    var entityStart = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/
    var entityBody = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/
  
    function isWhitespace (c) {
      return c === ' ' || c === '\n' || c === '\r' || c === '\t'
    }
  
    function isQuote (c) {
      return c === '"' || c === '\''
    }
  
    function isAttribEnd (c) {
      return c === '>' || isWhitespace(c)
    }
  
    function isMatch (regex, c) {
      return regex.test(c)
    }
  
    function notMatch (regex, c) {
      return !isMatch(regex, c)
    }
  
    var S = 0
    sax.STATE = {
      BEGIN: S++, // leading byte order mark or whitespace
      BEGIN_WHITESPACE: S++, // leading whitespace
      TEXT: S++, // general stuff
      TEXT_ENTITY: S++, // &amp and such.
      OPEN_WAKA: S++, // <
      SGML_DECL: S++, // <!BLARG
      SGML_DECL_QUOTED: S++, // <!BLARG foo "bar
      DOCTYPE: S++, // <!DOCTYPE
      DOCTYPE_QUOTED: S++, // <!DOCTYPE "//blah
      DOCTYPE_DTD: S++, // <!DOCTYPE "//blah" [ ...
      DOCTYPE_DTD_QUOTED: S++, // <!DOCTYPE "//blah" [ "foo
      COMMENT_STARTING: S++, // <!-
      COMMENT: S++, // <!--
      COMMENT_ENDING: S++, // <!-- blah -
      COMMENT_ENDED: S++, // <!-- blah --
      CDATA: S++, // <![CDATA[ something
      CDATA_ENDING: S++, // ]
      CDATA_ENDING_2: S++, // ]]
      PROC_INST: S++, // <?hi
      PROC_INST_BODY: S++, // <?hi there
      PROC_INST_ENDING: S++, // <?hi "there" ?
      OPEN_TAG: S++, // <strong
      OPEN_TAG_SLASH: S++, // <strong /
      ATTRIB: S++, // <a
      ATTRIB_NAME: S++, // <a foo
      ATTRIB_NAME_SAW_WHITE: S++, // <a foo _
      ATTRIB_VALUE: S++, // <a foo=
      ATTRIB_VALUE_QUOTED: S++, // <a foo="bar
      ATTRIB_VALUE_CLOSED: S++, // <a foo="bar"
      ATTRIB_VALUE_UNQUOTED: S++, // <a foo=bar
      ATTRIB_VALUE_ENTITY_Q: S++, // <foo bar="&quot;"
      ATTRIB_VALUE_ENTITY_U: S++, // <foo bar=&quot
      CLOSE_TAG: S++, // </a
      CLOSE_TAG_SAW_WHITE: S++, // </a   >
      SCRIPT: S++, // <script> ...
      SCRIPT_ENDING: S++ // <script> ... <
    }
  
    sax.XML_ENTITIES = {
      'amp': '&',
      'gt': '>',
      'lt': '<',
      'quot': '"',
      'apos': "'"
    }
  
    sax.ENTITIES = {
      'amp': '&',
      'gt': '>',
      'lt': '<',
      'quot': '"',
      'apos': "'",
      'AElig': 198,
      'Aacute': 193,
      'Acirc': 194,
      'Agrave': 192,
      'Aring': 197,
      'Atilde': 195,
      'Auml': 196,
      'Ccedil': 199,
      'ETH': 208,
      'Eacute': 201,
      'Ecirc': 202,
      'Egrave': 200,
      'Euml': 203,
      'Iacute': 205,
      'Icirc': 206,
      'Igrave': 204,
      'Iuml': 207,
      'Ntilde': 209,
      'Oacute': 211,
      'Ocirc': 212,
      'Ograve': 210,
      'Oslash': 216,
      'Otilde': 213,
      'Ouml': 214,
      'THORN': 222,
      'Uacute': 218,
      'Ucirc': 219,
      'Ugrave': 217,
      'Uuml': 220,
      'Yacute': 221,
      'aacute': 225,
      'acirc': 226,
      'aelig': 230,
      'agrave': 224,
      'aring': 229,
      'atilde': 227,
      'auml': 228,
      'ccedil': 231,
      'eacute': 233,
      'ecirc': 234,
      'egrave': 232,
      'eth': 240,
      'euml': 235,
      'iacute': 237,
      'icirc': 238,
      'igrave': 236,
      'iuml': 239,
      'ntilde': 241,
      'oacute': 243,
      'ocirc': 244,
      'ograve': 242,
      'oslash': 248,
      'otilde': 245,
      'ouml': 246,
      'szlig': 223,
      'thorn': 254,
      'uacute': 250,
      'ucirc': 251,
      'ugrave': 249,
      'uuml': 252,
      'yacute': 253,
      'yuml': 255,
      'copy': 169,
      'reg': 174,
      'nbsp': 160,
      'iexcl': 161,
      'cent': 162,
      'pound': 163,
      'curren': 164,
      'yen': 165,
      'brvbar': 166,
      'sect': 167,
      'uml': 168,
      'ordf': 170,
      'laquo': 171,
      'not': 172,
      'shy': 173,
      'macr': 175,
      'deg': 176,
      'plusmn': 177,
      'sup1': 185,
      'sup2': 178,
      'sup3': 179,
      'acute': 180,
      'micro': 181,
      'para': 182,
      'middot': 183,
      'cedil': 184,
      'ordm': 186,
      'raquo': 187,
      'frac14': 188,
      'frac12': 189,
      'frac34': 190,
      'iquest': 191,
      'times': 215,
      'divide': 247,
      'OElig': 338,
      'oelig': 339,
      'Scaron': 352,
      'scaron': 353,
      'Yuml': 376,
      'fnof': 402,
      'circ': 710,
      'tilde': 732,
      'Alpha': 913,
      'Beta': 914,
      'Gamma': 915,
      'Delta': 916,
      'Epsilon': 917,
      'Zeta': 918,
      'Eta': 919,
      'Theta': 920,
      'Iota': 921,
      'Kappa': 922,
      'Lambda': 923,
      'Mu': 924,
      'Nu': 925,
      'Xi': 926,
      'Omicron': 927,
      'Pi': 928,
      'Rho': 929,
      'Sigma': 931,
      'Tau': 932,
      'Upsilon': 933,
      'Phi': 934,
      'Chi': 935,
      'Psi': 936,
      'Omega': 937,
      'alpha': 945,
      'beta': 946,
      'gamma': 947,
      'delta': 948,
      'epsilon': 949,
      'zeta': 950,
      'eta': 951,
      'theta': 952,
      'iota': 953,
      'kappa': 954,
      'lambda': 955,
      'mu': 956,
      'nu': 957,
      'xi': 958,
      'omicron': 959,
      'pi': 960,
      'rho': 961,
      'sigmaf': 962,
      'sigma': 963,
      'tau': 964,
      'upsilon': 965,
      'phi': 966,
      'chi': 967,
      'psi': 968,
      'omega': 969,
      'thetasym': 977,
      'upsih': 978,
      'piv': 982,
      'ensp': 8194,
      'emsp': 8195,
      'thinsp': 8201,
      'zwnj': 8204,
      'zwj': 8205,
      'lrm': 8206,
      'rlm': 8207,
      'ndash': 8211,
      'mdash': 8212,
      'lsquo': 8216,
      'rsquo': 8217,
      'sbquo': 8218,
      'ldquo': 8220,
      'rdquo': 8221,
      'bdquo': 8222,
      'dagger': 8224,
      'Dagger': 8225,
      'bull': 8226,
      'hellip': 8230,
      'permil': 8240,
      'prime': 8242,
      'Prime': 8243,
      'lsaquo': 8249,
      'rsaquo': 8250,
      'oline': 8254,
      'frasl': 8260,
      'euro': 8364,
      'image': 8465,
      'weierp': 8472,
      'real': 8476,
      'trade': 8482,
      'alefsym': 8501,
      'larr': 8592,
      'uarr': 8593,
      'rarr': 8594,
      'darr': 8595,
      'harr': 8596,
      'crarr': 8629,
      'lArr': 8656,
      'uArr': 8657,
      'rArr': 8658,
      'dArr': 8659,
      'hArr': 8660,
      'forall': 8704,
      'part': 8706,
      'exist': 8707,
      'empty': 8709,
      'nabla': 8711,
      'isin': 8712,
      'notin': 8713,
      'ni': 8715,
      'prod': 8719,
      'sum': 8721,
      'minus': 8722,
      'lowast': 8727,
      'radic': 8730,
      'prop': 8733,
      'infin': 8734,
      'ang': 8736,
      'and': 8743,
      'or': 8744,
      'cap': 8745,
      'cup': 8746,
      'int': 8747,
      'there4': 8756,
      'sim': 8764,
      'cong': 8773,
      'asymp': 8776,
      'ne': 8800,
      'equiv': 8801,
      'le': 8804,
      'ge': 8805,
      'sub': 8834,
      'sup': 8835,
      'nsub': 8836,
      'sube': 8838,
      'supe': 8839,
      'oplus': 8853,
      'otimes': 8855,
      'perp': 8869,
      'sdot': 8901,
      'lceil': 8968,
      'rceil': 8969,
      'lfloor': 8970,
      'rfloor': 8971,
      'lang': 9001,
      'rang': 9002,
      'loz': 9674,
      'spades': 9824,
      'clubs': 9827,
      'hearts': 9829,
      'diams': 9830
    }
  
    Object.keys(sax.ENTITIES).forEach(function (key) {
      var e = sax.ENTITIES[key]
      var s = typeof e === 'number' ? String.fromCharCode(e) : e
      sax.ENTITIES[key] = s
    })
  
    for (var s in sax.STATE) {
      sax.STATE[sax.STATE[s]] = s
    }
  
    // shorthand
    S = sax.STATE
  
    function emit (parser, event, data) {
      parser[event] && parser[event](data)
    }
  
    function emitNode (parser, nodeType, data) {
      if (parser.textNode) closeText(parser)
      emit(parser, nodeType, data)
    }
  
    function closeText (parser) {
      parser.textNode = textopts(parser.opt, parser.textNode)
      if (parser.textNode) emit(parser, 'ontext', parser.textNode)
      parser.textNode = ''
    }
  
    function textopts (opt, text) {
      if (opt.trim) text = text.trim()
      if (opt.normalize) text = text.replace(/\s+/g, ' ')
      return text
    }
  
    function error (parser, er) {
      closeText(parser)
      if (parser.trackPosition) {
        er += '\nLine: ' + parser.line +
          '\nColumn: ' + parser.column +
          '\nChar: ' + parser.c
      }
      er = new Error(er)
      parser.error = er
      emit(parser, 'onerror', er)
      return parser
    }
  
    function end (parser) {
      if (parser.sawRoot && !parser.closedRoot) strictFail(parser, 'Unclosed root tag')
      if ((parser.state !== S.BEGIN) &&
        (parser.state !== S.BEGIN_WHITESPACE) &&
        (parser.state !== S.TEXT)) {
        error(parser, 'Unexpected end')
      }
      closeText(parser)
      parser.c = ''
      parser.closed = true
      emit(parser, 'onend')
      SAXParser.call(parser, parser.strict, parser.opt)
      return parser
    }
  
    function strictFail (parser, message) {
      if (typeof parser !== 'object' || !(parser instanceof SAXParser)) {
        throw new Error('bad call to strictFail')
      }
      if (parser.strict) {
        error(parser, message)
      }
    }
  
    function newTag (parser) {
      if (!parser.strict) parser.tagName = parser.tagName[parser.looseCase]()
      var parent = parser.tags[parser.tags.length - 1] || parser
      var tag = parser.tag = { name: parser.tagName, attributes: {} }
  
      // will be overridden if tag contails an xmlns="foo" or xmlns:foo="bar"
      if (parser.opt.xmlns) {
        tag.ns = parent.ns
      }
      parser.attribList.length = 0
      emitNode(parser, 'onopentagstart', tag)
    }
  
    function qname (name, attribute) {
      var i = name.indexOf(':')
      var qualName = i < 0 ? [ '', name ] : name.split(':')
      var prefix = qualName[0]
      var local = qualName[1]
  
      // <x "xmlns"="http://foo">
      if (attribute && name === 'xmlns') {
        prefix = 'xmlns'
        local = ''
      }
  
      return { prefix: prefix, local: local }
    }
  
    function attrib (parser) {
      if (!parser.strict) {
        parser.attribName = parser.attribName[parser.looseCase]()
      }
  
      if (parser.attribList.indexOf(parser.attribName) !== -1 ||
        parser.tag.attributes.hasOwnProperty(parser.attribName)) {
        parser.attribName = parser.attribValue = ''
        return
      }
  
      if (parser.opt.xmlns) {
        var qn = qname(parser.attribName, true)
        var prefix = qn.prefix
        var local = qn.local
  
        if (prefix === 'xmlns') {
          // namespace binding attribute. push the binding into scope
          if (local === 'xml' && parser.attribValue !== XML_NAMESPACE) {
            strictFail(parser,
              'xml: prefix must be bound to ' + XML_NAMESPACE + '\n' +
              'Actual: ' + parser.attribValue)
          } else if (local === 'xmlns' && parser.attribValue !== XMLNS_NAMESPACE) {
            strictFail(parser,
              'xmlns: prefix must be bound to ' + XMLNS_NAMESPACE + '\n' +
              'Actual: ' + parser.attribValue)
          } else {
            var tag = parser.tag
            var parent = parser.tags[parser.tags.length - 1] || parser
            if (tag.ns === parent.ns) {
              tag.ns = Object.create(parent.ns)
            }
            tag.ns[local] = parser.attribValue
          }
        }
  
        // defer onattribute events until all attributes have been seen
        // so any new bindings can take effect. preserve attribute order
        // so deferred events can be emitted in document order
        parser.attribList.push([parser.attribName, parser.attribValue])
      } else {
        // in non-xmlns mode, we can emit the event right away
        parser.tag.attributes[parser.attribName] = parser.attribValue
        emitNode(parser, 'onattribute', {
          name: parser.attribName,
          value: parser.attribValue
        })
      }
  
      parser.attribName = parser.attribValue = ''
    }
  
    function openTag (parser, selfClosing) {
      if (parser.opt.xmlns) {
        // emit namespace binding events
        var tag = parser.tag
  
        // add namespace info to tag
        var qn = qname(parser.tagName)
        tag.prefix = qn.prefix
        tag.local = qn.local
        tag.uri = tag.ns[qn.prefix] || ''
  
        if (tag.prefix && !tag.uri) {
          strictFail(parser, 'Unbound namespace prefix: ' +
            JSON.stringify(parser.tagName))
          tag.uri = qn.prefix
        }
  
        var parent = parser.tags[parser.tags.length - 1] || parser
        if (tag.ns && parent.ns !== tag.ns) {
          Object.keys(tag.ns).forEach(function (p) {
            emitNode(parser, 'onopennamespace', {
              prefix: p,
              uri: tag.ns[p]
            })
          })
        }
  
        // handle deferred onattribute events
        // Note: do not apply default ns to attributes:
        //   http://www.w3.org/TR/REC-xml-names/#defaulting
        for (var i = 0, l = parser.attribList.length; i < l; i++) {
          var nv = parser.attribList[i]
          var name = nv[0]
          var value = nv[1]
          var qualName = qname(name, true)
          var prefix = qualName.prefix
          var local = qualName.local
          var uri = prefix === '' ? '' : (tag.ns[prefix] || '')
          var a = {
            name: name,
            value: value,
            prefix: prefix,
            local: local,
            uri: uri
          }
  
          // if there's any attributes with an undefined namespace,
          // then fail on them now.
          if (prefix && prefix !== 'xmlns' && !uri) {
            strictFail(parser, 'Unbound namespace prefix: ' +
              JSON.stringify(prefix))
            a.uri = prefix
          }
          parser.tag.attributes[name] = a
          emitNode(parser, 'onattribute', a)
        }
        parser.attribList.length = 0
      }
  
      parser.tag.isSelfClosing = !!selfClosing
  
      // process the tag
      parser.sawRoot = true
      parser.tags.push(parser.tag)
      emitNode(parser, 'onopentag', parser.tag)
      if (!selfClosing) {
        // special case for <script> in non-strict mode.
        if (!parser.noscript && parser.tagName.toLowerCase() === 'script') {
          parser.state = S.SCRIPT
        } else {
          parser.state = S.TEXT
        }
        parser.tag = null
        parser.tagName = ''
      }
      parser.attribName = parser.attribValue = ''
      parser.attribList.length = 0
    }
  
    function closeTag (parser) {
      if (!parser.tagName) {
        strictFail(parser, 'Weird empty close tag.')
        parser.textNode += '</>'
        parser.state = S.TEXT
        return
      }
  
      if (parser.script) {
        if (parser.tagName !== 'script') {
          parser.script += '</' + parser.tagName + '>'
          parser.tagName = ''
          parser.state = S.SCRIPT
          return
        }
        emitNode(parser, 'onscript', parser.script)
        parser.script = ''
      }
  
      // first make sure that the closing tag actually exists.
      // <a><b></c></b></a> will close everything, otherwise.
      var t = parser.tags.length
      var tagName = parser.tagName
      if (!parser.strict) {
        tagName = tagName[parser.looseCase]()
      }
      var closeTo = tagName
      while (t--) {
        var close = parser.tags[t]
        if (close.name !== closeTo) {
          // fail the first time in strict mode
          strictFail(parser, 'Unexpected close tag')
        } else {
          break
        }
      }
  
      // didn't find it.  we already failed for strict, so just abort.
      if (t < 0) {
        strictFail(parser, 'Unmatched closing tag: ' + parser.tagName)
        parser.textNode += '</' + parser.tagName + '>'
        parser.state = S.TEXT
        return
      }
      parser.tagName = tagName
      var s = parser.tags.length
      while (s-- > t) {
        var tag = parser.tag = parser.tags.pop()
        parser.tagName = parser.tag.name
        emitNode(parser, 'onclosetag', parser.tagName)
  
        var x = {}
        for (var i in tag.ns) {
          x[i] = tag.ns[i]
        }
  
        var parent = parser.tags[parser.tags.length - 1] || parser
        if (parser.opt.xmlns && tag.ns !== parent.ns) {
          // remove namespace bindings introduced by tag
          Object.keys(tag.ns).forEach(function (p) {
            var n = tag.ns[p]
            emitNode(parser, 'onclosenamespace', { prefix: p, uri: n })
          })
        }
      }
      if (t === 0) parser.closedRoot = true
      parser.tagName = parser.attribValue = parser.attribName = ''
      parser.attribList.length = 0
      parser.state = S.TEXT
    }
  
    function parseEntity (parser) {
      var entity = parser.entity
      var entityLC = entity.toLowerCase()
      var num
      var numStr = ''
  
      if (parser.ENTITIES[entity]) {
        return parser.ENTITIES[entity]
      }
      if (parser.ENTITIES[entityLC]) {
        return parser.ENTITIES[entityLC]
      }
      entity = entityLC
      if (entity.charAt(0) === '#') {
        if (entity.charAt(1) === 'x') {
          entity = entity.slice(2)
          num = parseInt(entity, 16)
          numStr = num.toString(16)
        } else {
          entity = entity.slice(1)
          num = parseInt(entity, 10)
          numStr = num.toString(10)
        }
      }
      entity = entity.replace(/^0+/, '')
      if (isNaN(num) || numStr.toLowerCase() !== entity) {
        strictFail(parser, 'Invalid character entity')
        return '&' + parser.entity + ';'
      }
  
      return String.fromCodePoint(num)
    }
  
    function beginWhiteSpace (parser, c) {
      if (c === '<') {
        parser.state = S.OPEN_WAKA
        parser.startTagPosition = parser.position
      } else if (!isWhitespace(c)) {
        // have to process this as a text node.
        // weird, but happens.
        strictFail(parser, 'Non-whitespace before first tag.')
        parser.textNode = c
        parser.state = S.TEXT
      }
    }
  
    function charAt (chunk, i) {
      var result = ''
      if (i < chunk.length) {
        result = chunk.charAt(i)
      }
      return result
    }
  
    function write (chunk) {
      var parser = this
      if (this.error) {
        throw this.error
      }
      if (parser.closed) {
        return error(parser,
          'Cannot write after close. Assign an onready handler.')
      }
      if (chunk === null) {
        return end(parser)
      }
      if (typeof chunk === 'object') {
        chunk = chunk.toString()
      }
      var i = 0
      var c = ''
      while (true) {
        c = charAt(chunk, i++)
        parser.c = c
  
        if (!c) {
          break
        }
  
        if (parser.trackPosition) {
          parser.position++
          if (c === '\n') {
            parser.line++
            parser.column = 0
          } else {
            parser.column++
          }
        }
  
        switch (parser.state) {
          case S.BEGIN:
            parser.state = S.BEGIN_WHITESPACE
            if (c === '\uFEFF') {
              continue
            }
            beginWhiteSpace(parser, c)
            continue
  
          case S.BEGIN_WHITESPACE:
            beginWhiteSpace(parser, c)
            continue
  
          case S.TEXT:
            if (parser.sawRoot && !parser.closedRoot) {
              var starti = i - 1
              while (c && c !== '<' && c !== '&') {
                c = charAt(chunk, i++)
                if (c && parser.trackPosition) {
                  parser.position++
                  if (c === '\n') {
                    parser.line++
                    parser.column = 0
                  } else {
                    parser.column++
                  }
                }
              }
              parser.textNode += chunk.substring(starti, i - 1)
            }
            if (c === '<' && !(parser.sawRoot && parser.closedRoot && !parser.strict)) {
              parser.state = S.OPEN_WAKA
              parser.startTagPosition = parser.position
            } else {
              if (!isWhitespace(c) && (!parser.sawRoot || parser.closedRoot)) {
                strictFail(parser, 'Text data outside of root node.')
              }
              if (c === '&') {
                parser.state = S.TEXT_ENTITY
              } else {
                parser.textNode += c
              }
            }
            continue
  
          case S.SCRIPT:
            // only non-strict
            if (c === '<') {
              parser.state = S.SCRIPT_ENDING
            } else {
              parser.script += c
            }
            continue
  
          case S.SCRIPT_ENDING:
            if (c === '/') {
              parser.state = S.CLOSE_TAG
            } else {
              parser.script += '<' + c
              parser.state = S.SCRIPT
            }
            continue
  
          case S.OPEN_WAKA:
            // either a /, ?, !, or text is coming next.
            if (c === '!') {
              parser.state = S.SGML_DECL
              parser.sgmlDecl = ''
            } else if (isWhitespace(c)) {
              // wait for it...
            } else if (isMatch(nameStart, c)) {
              parser.state = S.OPEN_TAG
              parser.tagName = c
            } else if (c === '/') {
              parser.state = S.CLOSE_TAG
              parser.tagName = ''
            } else if (c === '?') {
              parser.state = S.PROC_INST
              parser.procInstName = parser.procInstBody = ''
            } else {
              strictFail(parser, 'Unencoded <')
              // if there was some whitespace, then add that in.
              if (parser.startTagPosition + 1 < parser.position) {
                var pad = parser.position - parser.startTagPosition
                c = new Array(pad).join(' ') + c
              }
              parser.textNode += '<' + c
              parser.state = S.TEXT
            }
            continue
  
          case S.SGML_DECL:
            if ((parser.sgmlDecl + c).toUpperCase() === CDATA) {
              emitNode(parser, 'onopencdata')
              parser.state = S.CDATA
              parser.sgmlDecl = ''
              parser.cdata = ''
            } else if (parser.sgmlDecl + c === '--') {
              parser.state = S.COMMENT
              parser.comment = ''
              parser.sgmlDecl = ''
            } else if ((parser.sgmlDecl + c).toUpperCase() === DOCTYPE) {
              parser.state = S.DOCTYPE
              if (parser.doctype || parser.sawRoot) {
                strictFail(parser,
                  'Inappropriately located doctype declaration')
              }
              parser.doctype = ''
              parser.sgmlDecl = ''
            } else if (c === '>') {
              emitNode(parser, 'onsgmldeclaration', parser.sgmlDecl)
              parser.sgmlDecl = ''
              parser.state = S.TEXT
            } else if (isQuote(c)) {
              parser.state = S.SGML_DECL_QUOTED
              parser.sgmlDecl += c
            } else {
              parser.sgmlDecl += c
            }
            continue
  
          case S.SGML_DECL_QUOTED:
            if (c === parser.q) {
              parser.state = S.SGML_DECL
              parser.q = ''
            }
            parser.sgmlDecl += c
            continue
  
          case S.DOCTYPE:
            if (c === '>') {
              parser.state = S.TEXT
              emitNode(parser, 'ondoctype', parser.doctype)
              parser.doctype = true // just remember that we saw it.
            } else {
              parser.doctype += c
              if (c === '[') {
                parser.state = S.DOCTYPE_DTD
              } else if (isQuote(c)) {
                parser.state = S.DOCTYPE_QUOTED
                parser.q = c
              }
            }
            continue
  
          case S.DOCTYPE_QUOTED:
            parser.doctype += c
            if (c === parser.q) {
              parser.q = ''
              parser.state = S.DOCTYPE
            }
            continue
  
          case S.DOCTYPE_DTD:
            parser.doctype += c
            if (c === ']') {
              parser.state = S.DOCTYPE
            } else if (isQuote(c)) {
              parser.state = S.DOCTYPE_DTD_QUOTED
              parser.q = c
            }
            continue
  
          case S.DOCTYPE_DTD_QUOTED:
            parser.doctype += c
            if (c === parser.q) {
              parser.state = S.DOCTYPE_DTD
              parser.q = ''
            }
            continue
  
          case S.COMMENT:
            if (c === '-') {
              parser.state = S.COMMENT_ENDING
            } else {
              parser.comment += c
            }
            continue
  
          case S.COMMENT_ENDING:
            if (c === '-') {
              parser.state = S.COMMENT_ENDED
              parser.comment = textopts(parser.opt, parser.comment)
              if (parser.comment) {
                emitNode(parser, 'oncomment', parser.comment)
              }
              parser.comment = ''
            } else {
              parser.comment += '-' + c
              parser.state = S.COMMENT
            }
            continue
  
          case S.COMMENT_ENDED:
            if (c !== '>') {
              strictFail(parser, 'Malformed comment')
              // allow <!-- blah -- bloo --> in non-strict mode,
              // which is a comment of " blah -- bloo "
              parser.comment += '--' + c
              parser.state = S.COMMENT
            } else {
              parser.state = S.TEXT
            }
            continue
  
          case S.CDATA:
            if (c === ']') {
              parser.state = S.CDATA_ENDING
            } else {
              parser.cdata += c
            }
            continue
  
          case S.CDATA_ENDING:
            if (c === ']') {
              parser.state = S.CDATA_ENDING_2
            } else {
              parser.cdata += ']' + c
              parser.state = S.CDATA
            }
            continue
  
          case S.CDATA_ENDING_2:
            if (c === '>') {
              if (parser.cdata) {
                emitNode(parser, 'oncdata', parser.cdata)
              }
              emitNode(parser, 'onclosecdata')
              parser.cdata = ''
              parser.state = S.TEXT
            } else if (c === ']') {
              parser.cdata += ']'
            } else {
              parser.cdata += ']]' + c
              parser.state = S.CDATA
            }
            continue
  
          case S.PROC_INST:
            if (c === '?') {
              parser.state = S.PROC_INST_ENDING
            } else if (isWhitespace(c)) {
              parser.state = S.PROC_INST_BODY
            } else {
              parser.procInstName += c
            }
            continue
  
          case S.PROC_INST_BODY:
            if (!parser.procInstBody && isWhitespace(c)) {
              continue
            } else if (c === '?') {
              parser.state = S.PROC_INST_ENDING
            } else {
              parser.procInstBody += c
            }
            continue
  
          case S.PROC_INST_ENDING:
            if (c === '>') {
              emitNode(parser, 'onprocessinginstruction', {
                name: parser.procInstName,
                body: parser.procInstBody
              })
              parser.procInstName = parser.procInstBody = ''
              parser.state = S.TEXT
            } else {
              parser.procInstBody += '?' + c
              parser.state = S.PROC_INST_BODY
            }
            continue
  
          case S.OPEN_TAG:
            if (isMatch(nameBody, c)) {
              parser.tagName += c
            } else {
              newTag(parser)
              if (c === '>') {
                openTag(parser)
              } else if (c === '/') {
                parser.state = S.OPEN_TAG_SLASH
              } else {
                if (!isWhitespace(c)) {
                  strictFail(parser, 'Invalid character in tag name')
                }
                parser.state = S.ATTRIB
              }
            }
            continue
  
          case S.OPEN_TAG_SLASH:
            if (c === '>') {
              openTag(parser, true)
              closeTag(parser)
            } else {
              strictFail(parser, 'Forward-slash in opening tag not followed by >')
              parser.state = S.ATTRIB
            }
            continue
  
          case S.ATTRIB:
            // haven't read the attribute name yet.
            if (isWhitespace(c)) {
              continue
            } else if (c === '>') {
              openTag(parser)
            } else if (c === '/') {
              parser.state = S.OPEN_TAG_SLASH
            } else if (isMatch(nameStart, c)) {
              parser.attribName = c
              parser.attribValue = ''
              parser.state = S.ATTRIB_NAME
            } else {
              strictFail(parser, 'Invalid attribute name')
            }
            continue
  
          case S.ATTRIB_NAME:
            if (c === '=') {
              parser.state = S.ATTRIB_VALUE
            } else if (c === '>') {
              strictFail(parser, 'Attribute without value')
              parser.attribValue = parser.attribName
              attrib(parser)
              openTag(parser)
            } else if (isWhitespace(c)) {
              parser.state = S.ATTRIB_NAME_SAW_WHITE
            } else if (isMatch(nameBody, c)) {
              parser.attribName += c
            } else {
              strictFail(parser, 'Invalid attribute name')
            }
            continue
  
          case S.ATTRIB_NAME_SAW_WHITE:
            if (c === '=') {
              parser.state = S.ATTRIB_VALUE
            } else if (isWhitespace(c)) {
              continue
            } else {
              strictFail(parser, 'Attribute without value')
              parser.tag.attributes[parser.attribName] = ''
              parser.attribValue = ''
              emitNode(parser, 'onattribute', {
                name: parser.attribName,
                value: ''
              })
              parser.attribName = ''
              if (c === '>') {
                openTag(parser)
              } else if (isMatch(nameStart, c)) {
                parser.attribName = c
                parser.state = S.ATTRIB_NAME
              } else {
                strictFail(parser, 'Invalid attribute name')
                parser.state = S.ATTRIB
              }
            }
            continue
  
          case S.ATTRIB_VALUE:
            if (isWhitespace(c)) {
              continue
            } else if (isQuote(c)) {
              parser.q = c
              parser.state = S.ATTRIB_VALUE_QUOTED
            } else {
              strictFail(parser, 'Unquoted attribute value')
              parser.state = S.ATTRIB_VALUE_UNQUOTED
              parser.attribValue = c
            }
            continue
  
          case S.ATTRIB_VALUE_QUOTED:
            if (c !== parser.q) {
              if (c === '&') {
                parser.state = S.ATTRIB_VALUE_ENTITY_Q
              } else {
                parser.attribValue += c
              }
              continue
            }
            attrib(parser)
            parser.q = ''
            parser.state = S.ATTRIB_VALUE_CLOSED
            continue
  
          case S.ATTRIB_VALUE_CLOSED:
            if (isWhitespace(c)) {
              parser.state = S.ATTRIB
            } else if (c === '>') {
              openTag(parser)
            } else if (c === '/') {
              parser.state = S.OPEN_TAG_SLASH
            } else if (isMatch(nameStart, c)) {
              strictFail(parser, 'No whitespace between attributes')
              parser.attribName = c
              parser.attribValue = ''
              parser.state = S.ATTRIB_NAME
            } else {
              strictFail(parser, 'Invalid attribute name')
            }
            continue
  
          case S.ATTRIB_VALUE_UNQUOTED:
            if (!isAttribEnd(c)) {
              if (c === '&') {
                parser.state = S.ATTRIB_VALUE_ENTITY_U
              } else {
                parser.attribValue += c
              }
              continue
            }
            attrib(parser)
            if (c === '>') {
              openTag(parser)
            } else {
              parser.state = S.ATTRIB
            }
            continue
  
          case S.CLOSE_TAG:
            if (!parser.tagName) {
              if (isWhitespace(c)) {
                continue
              } else if (notMatch(nameStart, c)) {
                if (parser.script) {
                  parser.script += '</' + c
                  parser.state = S.SCRIPT
                } else {
                  strictFail(parser, 'Invalid tagname in closing tag.')
                }
              } else {
                parser.tagName = c
              }
            } else if (c === '>') {
              closeTag(parser)
            } else if (isMatch(nameBody, c)) {
              parser.tagName += c
            } else if (parser.script) {
              parser.script += '</' + parser.tagName
              parser.tagName = ''
              parser.state = S.SCRIPT
            } else {
              if (!isWhitespace(c)) {
                strictFail(parser, 'Invalid tagname in closing tag')
              }
              parser.state = S.CLOSE_TAG_SAW_WHITE
            }
            continue
  
          case S.CLOSE_TAG_SAW_WHITE:
            if (isWhitespace(c)) {
              continue
            }
            if (c === '>') {
              closeTag(parser)
            } else {
              strictFail(parser, 'Invalid characters in closing tag')
            }
            continue
  
          case S.TEXT_ENTITY:
          case S.ATTRIB_VALUE_ENTITY_Q:
          case S.ATTRIB_VALUE_ENTITY_U:
            var returnState
            var buffer
            switch (parser.state) {
              case S.TEXT_ENTITY:
                returnState = S.TEXT
                buffer = 'textNode'
                break
  
              case S.ATTRIB_VALUE_ENTITY_Q:
                returnState = S.ATTRIB_VALUE_QUOTED
                buffer = 'attribValue'
                break
  
              case S.ATTRIB_VALUE_ENTITY_U:
                returnState = S.ATTRIB_VALUE_UNQUOTED
                buffer = 'attribValue'
                break
            }
  
            if (c === ';') {
              parser[buffer] += parseEntity(parser)
              parser.entity = ''
              parser.state = returnState
            } else if (isMatch(parser.entity.length ? entityBody : entityStart, c)) {
              parser.entity += c
            } else {
              strictFail(parser, 'Invalid character in entity name')
              parser[buffer] += '&' + parser.entity + c
              parser.entity = ''
              parser.state = returnState
            }
  
            continue
  
          default:
            throw new Error(parser, 'Unknown state: ' + parser.state)
        }
      } // while
  
      if (parser.position >= parser.bufferCheckPosition) {
        checkBufferLength(parser)
      }
      return parser
    }
  
    /*! http://mths.be/fromcodepoint v0.1.0 by @mathias */
    /* istanbul ignore next */
    if (!String.fromCodePoint) {
      (function () {
        var stringFromCharCode = String.fromCharCode
        var floor = Math.floor
        var fromCodePoint = function () {
          var MAX_SIZE = 0x4000
          var codeUnits = []
          var highSurrogate
          var lowSurrogate
          var index = -1
          var length = arguments.length
          if (!length) {
            return ''
          }
          var result = ''
          while (++index < length) {
            var codePoint = Number(arguments[index])
            if (
              !isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity`
              codePoint < 0 || // not a valid Unicode code point
              codePoint > 0x10FFFF || // not a valid Unicode code point
              floor(codePoint) !== codePoint // not an integer
            ) {
              throw RangeError('Invalid code point: ' + codePoint)
            }
            if (codePoint <= 0xFFFF) { // BMP code point
              codeUnits.push(codePoint)
            } else { // Astral code point; split in surrogate halves
              // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
              codePoint -= 0x10000
              highSurrogate = (codePoint >> 10) + 0xD800
              lowSurrogate = (codePoint % 0x400) + 0xDC00
              codeUnits.push(highSurrogate, lowSurrogate)
            }
            if (index + 1 === length || codeUnits.length > MAX_SIZE) {
              result += stringFromCharCode.apply(null, codeUnits)
              codeUnits.length = 0
            }
          }
          return result
        }
        /* istanbul ignore next */
        if (Object.defineProperty) {
          Object.defineProperty(String, 'fromCodePoint', {
            value: fromCodePoint,
            configurable: true,
            writable: true
          })
        } else {
          String.fromCodePoint = fromCodePoint
        }
      }())
    }
  })( false ? 0 : exports)
  
  
  /***/ }),
  
  /***/ 2624:
  /***/ (function(__unused_webpack_module, exports) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    "use strict";
    exports.stripBOM = function(str) {
      if (str[0] === '\uFEFF') {
        return str.substring(1);
      } else {
        return str;
      }
    };
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 3337:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    "use strict";
    var builder, defaults, escapeCDATA, requiresCDATA, wrapCDATA,
      hasProp = {}.hasOwnProperty;
  
    builder = __nccwpck_require__(2958);
  
    defaults = __nccwpck_require__(7251).defaults;
  
    requiresCDATA = function(entry) {
      return typeof entry === "string" && (entry.indexOf('&') >= 0 || entry.indexOf('>') >= 0 || entry.indexOf('<') >= 0);
    };
  
    wrapCDATA = function(entry) {
      return "<![CDATA[" + (escapeCDATA(entry)) + "]]>";
    };
  
    escapeCDATA = function(entry) {
      return entry.replace(']]>', ']]]]><![CDATA[>');
    };
  
    exports.Builder = (function() {
      function Builder(opts) {
        var key, ref, value;
        this.options = {};
        ref = defaults["0.2"];
        for (key in ref) {
          if (!hasProp.call(ref, key)) continue;
          value = ref[key];
          this.options[key] = value;
        }
        for (key in opts) {
          if (!hasProp.call(opts, key)) continue;
          value = opts[key];
          this.options[key] = value;
        }
      }
  
      Builder.prototype.buildObject = function(rootObj) {
        var attrkey, charkey, render, rootElement, rootName;
        attrkey = this.options.attrkey;
        charkey = this.options.charkey;
        if ((Object.keys(rootObj).length === 1) && (this.options.rootName === defaults['0.2'].rootName)) {
          rootName = Object.keys(rootObj)[0];
          rootObj = rootObj[rootName];
        } else {
          rootName = this.options.rootName;
        }
        render = (function(_this) {
          return function(element, obj) {
            var attr, child, entry, index, key, value;
            if (typeof obj !== 'object') {
              if (_this.options.cdata && requiresCDATA(obj)) {
                element.raw(wrapCDATA(obj));
              } else {
                element.txt(obj);
              }
            } else if (Array.isArray(obj)) {
              for (index in obj) {
                if (!hasProp.call(obj, index)) continue;
                child = obj[index];
                for (key in child) {
                  entry = child[key];
                  element = render(element.ele(key), entry).up();
                }
              }
            } else {
              for (key in obj) {
                if (!hasProp.call(obj, key)) continue;
                child = obj[key];
                if (key === attrkey) {
                  if (typeof child === "object") {
                    for (attr in child) {
                      value = child[attr];
                      element = element.att(attr, value);
                    }
                  }
                } else if (key === charkey) {
                  if (_this.options.cdata && requiresCDATA(child)) {
                    element = element.raw(wrapCDATA(child));
                  } else {
                    element = element.txt(child);
                  }
                } else if (Array.isArray(child)) {
                  for (index in child) {
                    if (!hasProp.call(child, index)) continue;
                    entry = child[index];
                    if (typeof entry === 'string') {
                      if (_this.options.cdata && requiresCDATA(entry)) {
                        element = element.ele(key).raw(wrapCDATA(entry)).up();
                      } else {
                        element = element.ele(key, entry).up();
                      }
                    } else {
                      element = render(element.ele(key), entry).up();
                    }
                  }
                } else if (typeof child === "object") {
                  element = render(element.ele(key), child).up();
                } else {
                  if (typeof child === 'string' && _this.options.cdata && requiresCDATA(child)) {
                    element = element.ele(key).raw(wrapCDATA(child)).up();
                  } else {
                    if (child == null) {
                      child = '';
                    }
                    element = element.ele(key, child.toString()).up();
                  }
                }
              }
            }
            return element;
          };
        })(this);
        rootElement = builder.create(rootName, this.options.xmldec, this.options.doctype, {
          headless: this.options.headless,
          allowSurrogateChars: this.options.allowSurrogateChars
        });
        return render(rootElement, rootObj).end(this.options.renderOpts);
      };
  
      return Builder;
  
    })();
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 7251:
  /***/ (function(__unused_webpack_module, exports) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    exports.defaults = {
      "0.1": {
        explicitCharkey: false,
        trim: true,
        normalize: true,
        normalizeTags: false,
        attrkey: "@",
        charkey: "#",
        explicitArray: false,
        ignoreAttrs: false,
        mergeAttrs: false,
        explicitRoot: false,
        validator: null,
        xmlns: false,
        explicitChildren: false,
        childkey: '@@',
        charsAsChildren: false,
        includeWhiteChars: false,
        async: false,
        strict: true,
        attrNameProcessors: null,
        attrValueProcessors: null,
        tagNameProcessors: null,
        valueProcessors: null,
        emptyTag: ''
      },
      "0.2": {
        explicitCharkey: false,
        trim: false,
        normalize: false,
        normalizeTags: false,
        attrkey: "$",
        charkey: "_",
        explicitArray: true,
        ignoreAttrs: false,
        mergeAttrs: false,
        explicitRoot: true,
        validator: null,
        xmlns: false,
        explicitChildren: false,
        preserveChildrenOrder: false,
        childkey: '$$',
        charsAsChildren: false,
        includeWhiteChars: false,
        async: false,
        strict: true,
        attrNameProcessors: null,
        attrValueProcessors: null,
        tagNameProcessors: null,
        valueProcessors: null,
        rootName: 'root',
        xmldec: {
          'version': '1.0',
          'encoding': 'UTF-8',
          'standalone': true
        },
        doctype: null,
        renderOpts: {
          'pretty': true,
          'indent': '  ',
          'newline': '\n'
        },
        headless: false,
        chunkSize: 10000,
        emptyTag: '',
        cdata: false
      }
    };
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 3314:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    "use strict";
    var bom, defaults, events, isEmpty, processItem, processors, sax, setImmediate,
      bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
      extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
      hasProp = {}.hasOwnProperty;
  
    sax = __nccwpck_require__(2043);
  
    events = __nccwpck_require__(8614);
  
    bom = __nccwpck_require__(2624);
  
    processors = __nccwpck_require__(9236);
  
    setImmediate = __nccwpck_require__(8213).setImmediate;
  
    defaults = __nccwpck_require__(7251).defaults;
  
    isEmpty = function(thing) {
      return typeof thing === "object" && (thing != null) && Object.keys(thing).length === 0;
    };
  
    processItem = function(processors, item, key) {
      var i, len, process;
      for (i = 0, len = processors.length; i < len; i++) {
        process = processors[i];
        item = process(item, key);
      }
      return item;
    };
  
    exports.Parser = (function(superClass) {
      extend(Parser, superClass);
  
      function Parser(opts) {
        this.parseStringPromise = bind(this.parseStringPromise, this);
        this.parseString = bind(this.parseString, this);
        this.reset = bind(this.reset, this);
        this.assignOrPush = bind(this.assignOrPush, this);
        this.processAsync = bind(this.processAsync, this);
        var key, ref, value;
        if (!(this instanceof exports.Parser)) {
          return new exports.Parser(opts);
        }
        this.options = {};
        ref = defaults["0.2"];
        for (key in ref) {
          if (!hasProp.call(ref, key)) continue;
          value = ref[key];
          this.options[key] = value;
        }
        for (key in opts) {
          if (!hasProp.call(opts, key)) continue;
          value = opts[key];
          this.options[key] = value;
        }
        if (this.options.xmlns) {
          this.options.xmlnskey = this.options.attrkey + "ns";
        }
        if (this.options.normalizeTags) {
          if (!this.options.tagNameProcessors) {
            this.options.tagNameProcessors = [];
          }
          this.options.tagNameProcessors.unshift(processors.normalize);
        }
        this.reset();
      }
  
      Parser.prototype.processAsync = function() {
        var chunk, err;
        try {
          if (this.remaining.length <= this.options.chunkSize) {
            chunk = this.remaining;
            this.remaining = '';
            this.saxParser = this.saxParser.write(chunk);
            return this.saxParser.close();
          } else {
            chunk = this.remaining.substr(0, this.options.chunkSize);
            this.remaining = this.remaining.substr(this.options.chunkSize, this.remaining.length);
            this.saxParser = this.saxParser.write(chunk);
            return setImmediate(this.processAsync);
          }
        } catch (error1) {
          err = error1;
          if (!this.saxParser.errThrown) {
            this.saxParser.errThrown = true;
            return this.emit(err);
          }
        }
      };
  
      Parser.prototype.assignOrPush = function(obj, key, newValue) {
        if (!(key in obj)) {
          if (!this.options.explicitArray) {
            return obj[key] = newValue;
          } else {
            return obj[key] = [newValue];
          }
        } else {
          if (!(obj[key] instanceof Array)) {
            obj[key] = [obj[key]];
          }
          return obj[key].push(newValue);
        }
      };
  
      Parser.prototype.reset = function() {
        var attrkey, charkey, ontext, stack;
        this.removeAllListeners();
        this.saxParser = sax.parser(this.options.strict, {
          trim: false,
          normalize: false,
          xmlns: this.options.xmlns
        });
        this.saxParser.errThrown = false;
        this.saxParser.onerror = (function(_this) {
          return function(error) {
            _this.saxParser.resume();
            if (!_this.saxParser.errThrown) {
              _this.saxParser.errThrown = true;
              return _this.emit("error", error);
            }
          };
        })(this);
        this.saxParser.onend = (function(_this) {
          return function() {
            if (!_this.saxParser.ended) {
              _this.saxParser.ended = true;
              return _this.emit("end", _this.resultObject);
            }
          };
        })(this);
        this.saxParser.ended = false;
        this.EXPLICIT_CHARKEY = this.options.explicitCharkey;
        this.resultObject = null;
        stack = [];
        attrkey = this.options.attrkey;
        charkey = this.options.charkey;
        this.saxParser.onopentag = (function(_this) {
          return function(node) {
            var key, newValue, obj, processedKey, ref;
            obj = {};
            obj[charkey] = "";
            if (!_this.options.ignoreAttrs) {
              ref = node.attributes;
              for (key in ref) {
                if (!hasProp.call(ref, key)) continue;
                if (!(attrkey in obj) && !_this.options.mergeAttrs) {
                  obj[attrkey] = {};
                }
                newValue = _this.options.attrValueProcessors ? processItem(_this.options.attrValueProcessors, node.attributes[key], key) : node.attributes[key];
                processedKey = _this.options.attrNameProcessors ? processItem(_this.options.attrNameProcessors, key) : key;
                if (_this.options.mergeAttrs) {
                  _this.assignOrPush(obj, processedKey, newValue);
                } else {
                  obj[attrkey][processedKey] = newValue;
                }
              }
            }
            obj["#name"] = _this.options.tagNameProcessors ? processItem(_this.options.tagNameProcessors, node.name) : node.name;
            if (_this.options.xmlns) {
              obj[_this.options.xmlnskey] = {
                uri: node.uri,
                local: node.local
              };
            }
            return stack.push(obj);
          };
        })(this);
        this.saxParser.onclosetag = (function(_this) {
          return function() {
            var cdata, emptyStr, key, node, nodeName, obj, objClone, old, s, xpath;
            obj = stack.pop();
            nodeName = obj["#name"];
            if (!_this.options.explicitChildren || !_this.options.preserveChildrenOrder) {
              delete obj["#name"];
            }
            if (obj.cdata === true) {
              cdata = obj.cdata;
              delete obj.cdata;
            }
            s = stack[stack.length - 1];
            if (obj[charkey].match(/^\s*$/) && !cdata) {
              emptyStr = obj[charkey];
              delete obj[charkey];
            } else {
              if (_this.options.trim) {
                obj[charkey] = obj[charkey].trim();
              }
              if (_this.options.normalize) {
                obj[charkey] = obj[charkey].replace(/\s{2,}/g, " ").trim();
              }
              obj[charkey] = _this.options.valueProcessors ? processItem(_this.options.valueProcessors, obj[charkey], nodeName) : obj[charkey];
              if (Object.keys(obj).length === 1 && charkey in obj && !_this.EXPLICIT_CHARKEY) {
                obj = obj[charkey];
              }
            }
            if (isEmpty(obj)) {
              obj = _this.options.emptyTag !== '' ? _this.options.emptyTag : emptyStr;
            }
            if (_this.options.validator != null) {
              xpath = "/" + ((function() {
                var i, len, results;
                results = [];
                for (i = 0, len = stack.length; i < len; i++) {
                  node = stack[i];
                  results.push(node["#name"]);
                }
                return results;
              })()).concat(nodeName).join("/");
              (function() {
                var err;
                try {
                  return obj = _this.options.validator(xpath, s && s[nodeName], obj);
                } catch (error1) {
                  err = error1;
                  return _this.emit("error", err);
                }
              })();
            }
            if (_this.options.explicitChildren && !_this.options.mergeAttrs && typeof obj === 'object') {
              if (!_this.options.preserveChildrenOrder) {
                node = {};
                if (_this.options.attrkey in obj) {
                  node[_this.options.attrkey] = obj[_this.options.attrkey];
                  delete obj[_this.options.attrkey];
                }
                if (!_this.options.charsAsChildren && _this.options.charkey in obj) {
                  node[_this.options.charkey] = obj[_this.options.charkey];
                  delete obj[_this.options.charkey];
                }
                if (Object.getOwnPropertyNames(obj).length > 0) {
                  node[_this.options.childkey] = obj;
                }
                obj = node;
              } else if (s) {
                s[_this.options.childkey] = s[_this.options.childkey] || [];
                objClone = {};
                for (key in obj) {
                  if (!hasProp.call(obj, key)) continue;
                  objClone[key] = obj[key];
                }
                s[_this.options.childkey].push(objClone);
                delete obj["#name"];
                if (Object.keys(obj).length === 1 && charkey in obj && !_this.EXPLICIT_CHARKEY) {
                  obj = obj[charkey];
                }
              }
            }
            if (stack.length > 0) {
              return _this.assignOrPush(s, nodeName, obj);
            } else {
              if (_this.options.explicitRoot) {
                old = obj;
                obj = {};
                obj[nodeName] = old;
              }
              _this.resultObject = obj;
              _this.saxParser.ended = true;
              return _this.emit("end", _this.resultObject);
            }
          };
        })(this);
        ontext = (function(_this) {
          return function(text) {
            var charChild, s;
            s = stack[stack.length - 1];
            if (s) {
              s[charkey] += text;
              if (_this.options.explicitChildren && _this.options.preserveChildrenOrder && _this.options.charsAsChildren && (_this.options.includeWhiteChars || text.replace(/\\n/g, '').trim() !== '')) {
                s[_this.options.childkey] = s[_this.options.childkey] || [];
                charChild = {
                  '#name': '__text__'
                };
                charChild[charkey] = text;
                if (_this.options.normalize) {
                  charChild[charkey] = charChild[charkey].replace(/\s{2,}/g, " ").trim();
                }
                s[_this.options.childkey].push(charChild);
              }
              return s;
            }
          };
        })(this);
        this.saxParser.ontext = ontext;
        return this.saxParser.oncdata = (function(_this) {
          return function(text) {
            var s;
            s = ontext(text);
            if (s) {
              return s.cdata = true;
            }
          };
        })(this);
      };
  
      Parser.prototype.parseString = function(str, cb) {
        var err;
        if ((cb != null) && typeof cb === "function") {
          this.on("end", function(result) {
            this.reset();
            return cb(null, result);
          });
          this.on("error", function(err) {
            this.reset();
            return cb(err);
          });
        }
        try {
          str = str.toString();
          if (str.trim() === '') {
            this.emit("end", null);
            return true;
          }
          str = bom.stripBOM(str);
          if (this.options.async) {
            this.remaining = str;
            setImmediate(this.processAsync);
            return this.saxParser;
          }
          return this.saxParser.write(str).close();
        } catch (error1) {
          err = error1;
          if (!(this.saxParser.errThrown || this.saxParser.ended)) {
            this.emit('error', err);
            return this.saxParser.errThrown = true;
          } else if (this.saxParser.ended) {
            throw err;
          }
        }
      };
  
      Parser.prototype.parseStringPromise = function(str) {
        return new Promise((function(_this) {
          return function(resolve, reject) {
            return _this.parseString(str, function(err, value) {
              if (err) {
                return reject(err);
              } else {
                return resolve(value);
              }
            });
          };
        })(this));
      };
  
      return Parser;
  
    })(events);
  
    exports.parseString = function(str, a, b) {
      var cb, options, parser;
      if (b != null) {
        if (typeof b === 'function') {
          cb = b;
        }
        if (typeof a === 'object') {
          options = a;
        }
      } else {
        if (typeof a === 'function') {
          cb = a;
        }
        options = {};
      }
      parser = new exports.Parser(options);
      return parser.parseString(str, cb);
    };
  
    exports.parseStringPromise = function(str, a) {
      var options, parser;
      if (typeof a === 'object') {
        options = a;
      }
      parser = new exports.Parser(options);
      return parser.parseStringPromise(str);
    };
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 9236:
  /***/ (function(__unused_webpack_module, exports) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    "use strict";
    var prefixMatch;
  
    prefixMatch = new RegExp(/(?!xmlns)^.*:/);
  
    exports.normalize = function(str) {
      return str.toLowerCase();
    };
  
    exports.firstCharLowerCase = function(str) {
      return str.charAt(0).toLowerCase() + str.slice(1);
    };
  
    exports.stripPrefix = function(str) {
      return str.replace(prefixMatch, '');
    };
  
    exports.parseNumbers = function(str) {
      if (!isNaN(str)) {
        str = str % 1 === 0 ? parseInt(str, 10) : parseFloat(str);
      }
      return str;
    };
  
    exports.parseBooleans = function(str) {
      if (/^(?:true|false)$/i.test(str)) {
        str = str.toLowerCase() === 'true';
      }
      return str;
    };
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 6189:
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    "use strict";
    var builder, defaults, parser, processors,
      extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
      hasProp = {}.hasOwnProperty;
  
    defaults = __nccwpck_require__(7251);
  
    builder = __nccwpck_require__(3337);
  
    parser = __nccwpck_require__(3314);
  
    processors = __nccwpck_require__(9236);
  
    exports.defaults = defaults.defaults;
  
    exports.processors = processors;
  
    exports.ValidationError = (function(superClass) {
      extend(ValidationError, superClass);
  
      function ValidationError(message) {
        this.message = message;
      }
  
      return ValidationError;
  
    })(Error);
  
    exports.Builder = builder.Builder;
  
    exports.Parser = parser.Parser;
  
    exports.parseString = parser.parseString;
  
    exports.parseStringPromise = parser.parseStringPromise;
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 2839:
  /***/ (function(module) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    module.exports = {
      Disconnected: 1,
      Preceding: 2,
      Following: 4,
      Contains: 8,
      ContainedBy: 16,
      ImplementationSpecific: 32
    };
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 9267:
  /***/ (function(module) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    module.exports = {
      Element: 1,
      Attribute: 2,
      Text: 3,
      CData: 4,
      EntityReference: 5,
      EntityDeclaration: 6,
      ProcessingInstruction: 7,
      Comment: 8,
      Document: 9,
      DocType: 10,
      DocumentFragment: 11,
      NotationDeclaration: 12,
      Declaration: 201,
      Raw: 202,
      AttributeDeclaration: 203,
      ElementDeclaration: 204,
      Dummy: 205
    };
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 8229:
  /***/ (function(module) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var assign, getValue, isArray, isEmpty, isFunction, isObject, isPlainObject,
      slice = [].slice,
      hasProp = {}.hasOwnProperty;
  
    assign = function() {
      var i, key, len, source, sources, target;
      target = arguments[0], sources = 2 <= arguments.length ? slice.call(arguments, 1) : [];
      if (isFunction(Object.assign)) {
        Object.assign.apply(null, arguments);
      } else {
        for (i = 0, len = sources.length; i < len; i++) {
          source = sources[i];
          if (source != null) {
            for (key in source) {
              if (!hasProp.call(source, key)) continue;
              target[key] = source[key];
            }
          }
        }
      }
      return target;
    };
  
    isFunction = function(val) {
      return !!val && Object.prototype.toString.call(val) === '[object Function]';
    };
  
    isObject = function(val) {
      var ref;
      return !!val && ((ref = typeof val) === 'function' || ref === 'object');
    };
  
    isArray = function(val) {
      if (isFunction(Array.isArray)) {
        return Array.isArray(val);
      } else {
        return Object.prototype.toString.call(val) === '[object Array]';
      }
    };
  
    isEmpty = function(val) {
      var key;
      if (isArray(val)) {
        return !val.length;
      } else {
        for (key in val) {
          if (!hasProp.call(val, key)) continue;
          return false;
        }
        return true;
      }
    };
  
    isPlainObject = function(val) {
      var ctor, proto;
      return isObject(val) && (proto = Object.getPrototypeOf(val)) && (ctor = proto.constructor) && (typeof ctor === 'function') && (ctor instanceof ctor) && (Function.prototype.toString.call(ctor) === Function.prototype.toString.call(Object));
    };
  
    getValue = function(obj) {
      if (isFunction(obj.valueOf)) {
        return obj.valueOf();
      } else {
        return obj;
      }
    };
  
    module.exports.assign = assign;
  
    module.exports.isFunction = isFunction;
  
    module.exports.isObject = isObject;
  
    module.exports.isArray = isArray;
  
    module.exports.isEmpty = isEmpty;
  
    module.exports.isPlainObject = isPlainObject;
  
    module.exports.getValue = getValue;
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 9766:
  /***/ (function(module) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    module.exports = {
      None: 0,
      OpenTag: 1,
      InsideTag: 2,
      CloseTag: 3
    };
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 8376:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var NodeType, XMLAttribute, XMLNode;
  
    NodeType = __nccwpck_require__(9267);
  
    XMLNode = __nccwpck_require__(7608);
  
    module.exports = XMLAttribute = (function() {
      function XMLAttribute(parent, name, value) {
        this.parent = parent;
        if (this.parent) {
          this.options = this.parent.options;
          this.stringify = this.parent.stringify;
        }
        if (name == null) {
          throw new Error("Missing attribute name. " + this.debugInfo(name));
        }
        this.name = this.stringify.name(name);
        this.value = this.stringify.attValue(value);
        this.type = NodeType.Attribute;
        this.isId = false;
        this.schemaTypeInfo = null;
      }
  
      Object.defineProperty(XMLAttribute.prototype, 'nodeType', {
        get: function() {
          return this.type;
        }
      });
  
      Object.defineProperty(XMLAttribute.prototype, 'ownerElement', {
        get: function() {
          return this.parent;
        }
      });
  
      Object.defineProperty(XMLAttribute.prototype, 'textContent', {
        get: function() {
          return this.value;
        },
        set: function(value) {
          return this.value = value || '';
        }
      });
  
      Object.defineProperty(XMLAttribute.prototype, 'namespaceURI', {
        get: function() {
          return '';
        }
      });
  
      Object.defineProperty(XMLAttribute.prototype, 'prefix', {
        get: function() {
          return '';
        }
      });
  
      Object.defineProperty(XMLAttribute.prototype, 'localName', {
        get: function() {
          return this.name;
        }
      });
  
      Object.defineProperty(XMLAttribute.prototype, 'specified', {
        get: function() {
          return true;
        }
      });
  
      XMLAttribute.prototype.clone = function() {
        return Object.create(this);
      };
  
      XMLAttribute.prototype.toString = function(options) {
        return this.options.writer.attribute(this, this.options.writer.filterOptions(options));
      };
  
      XMLAttribute.prototype.debugInfo = function(name) {
        name = name || this.name;
        if (name == null) {
          return "parent: <" + this.parent.name + ">";
        } else {
          return "attribute: {" + name + "}, parent: <" + this.parent.name + ">";
        }
      };
  
      XMLAttribute.prototype.isEqualNode = function(node) {
        if (node.namespaceURI !== this.namespaceURI) {
          return false;
        }
        if (node.prefix !== this.prefix) {
          return false;
        }
        if (node.localName !== this.localName) {
          return false;
        }
        if (node.value !== this.value) {
          return false;
        }
        return true;
      };
  
      return XMLAttribute;
  
    })();
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 333:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var NodeType, XMLCData, XMLCharacterData,
      extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
      hasProp = {}.hasOwnProperty;
  
    NodeType = __nccwpck_require__(9267);
  
    XMLCharacterData = __nccwpck_require__(7709);
  
    module.exports = XMLCData = (function(superClass) {
      extend(XMLCData, superClass);
  
      function XMLCData(parent, text) {
        XMLCData.__super__.constructor.call(this, parent);
        if (text == null) {
          throw new Error("Missing CDATA text. " + this.debugInfo());
        }
        this.name = "#cdata-section";
        this.type = NodeType.CData;
        this.value = this.stringify.cdata(text);
      }
  
      XMLCData.prototype.clone = function() {
        return Object.create(this);
      };
  
      XMLCData.prototype.toString = function(options) {
        return this.options.writer.cdata(this, this.options.writer.filterOptions(options));
      };
  
      return XMLCData;
  
    })(XMLCharacterData);
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 7709:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var XMLCharacterData, XMLNode,
      extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
      hasProp = {}.hasOwnProperty;
  
    XMLNode = __nccwpck_require__(7608);
  
    module.exports = XMLCharacterData = (function(superClass) {
      extend(XMLCharacterData, superClass);
  
      function XMLCharacterData(parent) {
        XMLCharacterData.__super__.constructor.call(this, parent);
        this.value = '';
      }
  
      Object.defineProperty(XMLCharacterData.prototype, 'data', {
        get: function() {
          return this.value;
        },
        set: function(value) {
          return this.value = value || '';
        }
      });
  
      Object.defineProperty(XMLCharacterData.prototype, 'length', {
        get: function() {
          return this.value.length;
        }
      });
  
      Object.defineProperty(XMLCharacterData.prototype, 'textContent', {
        get: function() {
          return this.value;
        },
        set: function(value) {
          return this.value = value || '';
        }
      });
  
      XMLCharacterData.prototype.clone = function() {
        return Object.create(this);
      };
  
      XMLCharacterData.prototype.substringData = function(offset, count) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLCharacterData.prototype.appendData = function(arg) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLCharacterData.prototype.insertData = function(offset, arg) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLCharacterData.prototype.deleteData = function(offset, count) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLCharacterData.prototype.replaceData = function(offset, count, arg) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLCharacterData.prototype.isEqualNode = function(node) {
        if (!XMLCharacterData.__super__.isEqualNode.apply(this, arguments).isEqualNode(node)) {
          return false;
        }
        if (node.data !== this.data) {
          return false;
        }
        return true;
      };
  
      return XMLCharacterData;
  
    })(XMLNode);
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 4407:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var NodeType, XMLCharacterData, XMLComment,
      extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
      hasProp = {}.hasOwnProperty;
  
    NodeType = __nccwpck_require__(9267);
  
    XMLCharacterData = __nccwpck_require__(7709);
  
    module.exports = XMLComment = (function(superClass) {
      extend(XMLComment, superClass);
  
      function XMLComment(parent, text) {
        XMLComment.__super__.constructor.call(this, parent);
        if (text == null) {
          throw new Error("Missing comment text. " + this.debugInfo());
        }
        this.name = "#comment";
        this.type = NodeType.Comment;
        this.value = this.stringify.comment(text);
      }
  
      XMLComment.prototype.clone = function() {
        return Object.create(this);
      };
  
      XMLComment.prototype.toString = function(options) {
        return this.options.writer.comment(this, this.options.writer.filterOptions(options));
      };
  
      return XMLComment;
  
    })(XMLCharacterData);
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 7465:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var XMLDOMConfiguration, XMLDOMErrorHandler, XMLDOMStringList;
  
    XMLDOMErrorHandler = __nccwpck_require__(6744);
  
    XMLDOMStringList = __nccwpck_require__(7028);
  
    module.exports = XMLDOMConfiguration = (function() {
      function XMLDOMConfiguration() {
        var clonedSelf;
        this.defaultParams = {
          "canonical-form": false,
          "cdata-sections": false,
          "comments": false,
          "datatype-normalization": false,
          "element-content-whitespace": true,
          "entities": true,
          "error-handler": new XMLDOMErrorHandler(),
          "infoset": true,
          "validate-if-schema": false,
          "namespaces": true,
          "namespace-declarations": true,
          "normalize-characters": false,
          "schema-location": '',
          "schema-type": '',
          "split-cdata-sections": true,
          "validate": false,
          "well-formed": true
        };
        this.params = clonedSelf = Object.create(this.defaultParams);
      }
  
      Object.defineProperty(XMLDOMConfiguration.prototype, 'parameterNames', {
        get: function() {
          return new XMLDOMStringList(Object.keys(this.defaultParams));
        }
      });
  
      XMLDOMConfiguration.prototype.getParameter = function(name) {
        if (this.params.hasOwnProperty(name)) {
          return this.params[name];
        } else {
          return null;
        }
      };
  
      XMLDOMConfiguration.prototype.canSetParameter = function(name, value) {
        return true;
      };
  
      XMLDOMConfiguration.prototype.setParameter = function(name, value) {
        if (value != null) {
          return this.params[name] = value;
        } else {
          return delete this.params[name];
        }
      };
  
      return XMLDOMConfiguration;
  
    })();
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 6744:
  /***/ (function(module) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var XMLDOMErrorHandler;
  
    module.exports = XMLDOMErrorHandler = (function() {
      function XMLDOMErrorHandler() {}
  
      XMLDOMErrorHandler.prototype.handleError = function(error) {
        throw new Error(error);
      };
  
      return XMLDOMErrorHandler;
  
    })();
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 8310:
  /***/ (function(module) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var XMLDOMImplementation;
  
    module.exports = XMLDOMImplementation = (function() {
      function XMLDOMImplementation() {}
  
      XMLDOMImplementation.prototype.hasFeature = function(feature, version) {
        return true;
      };
  
      XMLDOMImplementation.prototype.createDocumentType = function(qualifiedName, publicId, systemId) {
        throw new Error("This DOM method is not implemented.");
      };
  
      XMLDOMImplementation.prototype.createDocument = function(namespaceURI, qualifiedName, doctype) {
        throw new Error("This DOM method is not implemented.");
      };
  
      XMLDOMImplementation.prototype.createHTMLDocument = function(title) {
        throw new Error("This DOM method is not implemented.");
      };
  
      XMLDOMImplementation.prototype.getFeature = function(feature, version) {
        throw new Error("This DOM method is not implemented.");
      };
  
      return XMLDOMImplementation;
  
    })();
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 7028:
  /***/ (function(module) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var XMLDOMStringList;
  
    module.exports = XMLDOMStringList = (function() {
      function XMLDOMStringList(arr) {
        this.arr = arr || [];
      }
  
      Object.defineProperty(XMLDOMStringList.prototype, 'length', {
        get: function() {
          return this.arr.length;
        }
      });
  
      XMLDOMStringList.prototype.item = function(index) {
        return this.arr[index] || null;
      };
  
      XMLDOMStringList.prototype.contains = function(str) {
        return this.arr.indexOf(str) !== -1;
      };
  
      return XMLDOMStringList;
  
    })();
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 1015:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var NodeType, XMLDTDAttList, XMLNode,
      extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
      hasProp = {}.hasOwnProperty;
  
    XMLNode = __nccwpck_require__(7608);
  
    NodeType = __nccwpck_require__(9267);
  
    module.exports = XMLDTDAttList = (function(superClass) {
      extend(XMLDTDAttList, superClass);
  
      function XMLDTDAttList(parent, elementName, attributeName, attributeType, defaultValueType, defaultValue) {
        XMLDTDAttList.__super__.constructor.call(this, parent);
        if (elementName == null) {
          throw new Error("Missing DTD element name. " + this.debugInfo());
        }
        if (attributeName == null) {
          throw new Error("Missing DTD attribute name. " + this.debugInfo(elementName));
        }
        if (!attributeType) {
          throw new Error("Missing DTD attribute type. " + this.debugInfo(elementName));
        }
        if (!defaultValueType) {
          throw new Error("Missing DTD attribute default. " + this.debugInfo(elementName));
        }
        if (defaultValueType.indexOf('#') !== 0) {
          defaultValueType = '#' + defaultValueType;
        }
        if (!defaultValueType.match(/^(#REQUIRED|#IMPLIED|#FIXED|#DEFAULT)$/)) {
          throw new Error("Invalid default value type; expected: #REQUIRED, #IMPLIED, #FIXED or #DEFAULT. " + this.debugInfo(elementName));
        }
        if (defaultValue && !defaultValueType.match(/^(#FIXED|#DEFAULT)$/)) {
          throw new Error("Default value only applies to #FIXED or #DEFAULT. " + this.debugInfo(elementName));
        }
        this.elementName = this.stringify.name(elementName);
        this.type = NodeType.AttributeDeclaration;
        this.attributeName = this.stringify.name(attributeName);
        this.attributeType = this.stringify.dtdAttType(attributeType);
        if (defaultValue) {
          this.defaultValue = this.stringify.dtdAttDefault(defaultValue);
        }
        this.defaultValueType = defaultValueType;
      }
  
      XMLDTDAttList.prototype.toString = function(options) {
        return this.options.writer.dtdAttList(this, this.options.writer.filterOptions(options));
      };
  
      return XMLDTDAttList;
  
    })(XMLNode);
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 2421:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var NodeType, XMLDTDElement, XMLNode,
      extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
      hasProp = {}.hasOwnProperty;
  
    XMLNode = __nccwpck_require__(7608);
  
    NodeType = __nccwpck_require__(9267);
  
    module.exports = XMLDTDElement = (function(superClass) {
      extend(XMLDTDElement, superClass);
  
      function XMLDTDElement(parent, name, value) {
        XMLDTDElement.__super__.constructor.call(this, parent);
        if (name == null) {
          throw new Error("Missing DTD element name. " + this.debugInfo());
        }
        if (!value) {
          value = '(#PCDATA)';
        }
        if (Array.isArray(value)) {
          value = '(' + value.join(',') + ')';
        }
        this.name = this.stringify.name(name);
        this.type = NodeType.ElementDeclaration;
        this.value = this.stringify.dtdElementValue(value);
      }
  
      XMLDTDElement.prototype.toString = function(options) {
        return this.options.writer.dtdElement(this, this.options.writer.filterOptions(options));
      };
  
      return XMLDTDElement;
  
    })(XMLNode);
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 53:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var NodeType, XMLDTDEntity, XMLNode, isObject,
      extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
      hasProp = {}.hasOwnProperty;
  
    isObject = __nccwpck_require__(8229).isObject;
  
    XMLNode = __nccwpck_require__(7608);
  
    NodeType = __nccwpck_require__(9267);
  
    module.exports = XMLDTDEntity = (function(superClass) {
      extend(XMLDTDEntity, superClass);
  
      function XMLDTDEntity(parent, pe, name, value) {
        XMLDTDEntity.__super__.constructor.call(this, parent);
        if (name == null) {
          throw new Error("Missing DTD entity name. " + this.debugInfo(name));
        }
        if (value == null) {
          throw new Error("Missing DTD entity value. " + this.debugInfo(name));
        }
        this.pe = !!pe;
        this.name = this.stringify.name(name);
        this.type = NodeType.EntityDeclaration;
        if (!isObject(value)) {
          this.value = this.stringify.dtdEntityValue(value);
          this.internal = true;
        } else {
          if (!value.pubID && !value.sysID) {
            throw new Error("Public and/or system identifiers are required for an external entity. " + this.debugInfo(name));
          }
          if (value.pubID && !value.sysID) {
            throw new Error("System identifier is required for a public external entity. " + this.debugInfo(name));
          }
          this.internal = false;
          if (value.pubID != null) {
            this.pubID = this.stringify.dtdPubID(value.pubID);
          }
          if (value.sysID != null) {
            this.sysID = this.stringify.dtdSysID(value.sysID);
          }
          if (value.nData != null) {
            this.nData = this.stringify.dtdNData(value.nData);
          }
          if (this.pe && this.nData) {
            throw new Error("Notation declaration is not allowed in a parameter entity. " + this.debugInfo(name));
          }
        }
      }
  
      Object.defineProperty(XMLDTDEntity.prototype, 'publicId', {
        get: function() {
          return this.pubID;
        }
      });
  
      Object.defineProperty(XMLDTDEntity.prototype, 'systemId', {
        get: function() {
          return this.sysID;
        }
      });
  
      Object.defineProperty(XMLDTDEntity.prototype, 'notationName', {
        get: function() {
          return this.nData || null;
        }
      });
  
      Object.defineProperty(XMLDTDEntity.prototype, 'inputEncoding', {
        get: function() {
          return null;
        }
      });
  
      Object.defineProperty(XMLDTDEntity.prototype, 'xmlEncoding', {
        get: function() {
          return null;
        }
      });
  
      Object.defineProperty(XMLDTDEntity.prototype, 'xmlVersion', {
        get: function() {
          return null;
        }
      });
  
      XMLDTDEntity.prototype.toString = function(options) {
        return this.options.writer.dtdEntity(this, this.options.writer.filterOptions(options));
      };
  
      return XMLDTDEntity;
  
    })(XMLNode);
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 2837:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var NodeType, XMLDTDNotation, XMLNode,
      extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
      hasProp = {}.hasOwnProperty;
  
    XMLNode = __nccwpck_require__(7608);
  
    NodeType = __nccwpck_require__(9267);
  
    module.exports = XMLDTDNotation = (function(superClass) {
      extend(XMLDTDNotation, superClass);
  
      function XMLDTDNotation(parent, name, value) {
        XMLDTDNotation.__super__.constructor.call(this, parent);
        if (name == null) {
          throw new Error("Missing DTD notation name. " + this.debugInfo(name));
        }
        if (!value.pubID && !value.sysID) {
          throw new Error("Public or system identifiers are required for an external entity. " + this.debugInfo(name));
        }
        this.name = this.stringify.name(name);
        this.type = NodeType.NotationDeclaration;
        if (value.pubID != null) {
          this.pubID = this.stringify.dtdPubID(value.pubID);
        }
        if (value.sysID != null) {
          this.sysID = this.stringify.dtdSysID(value.sysID);
        }
      }
  
      Object.defineProperty(XMLDTDNotation.prototype, 'publicId', {
        get: function() {
          return this.pubID;
        }
      });
  
      Object.defineProperty(XMLDTDNotation.prototype, 'systemId', {
        get: function() {
          return this.sysID;
        }
      });
  
      XMLDTDNotation.prototype.toString = function(options) {
        return this.options.writer.dtdNotation(this, this.options.writer.filterOptions(options));
      };
  
      return XMLDTDNotation;
  
    })(XMLNode);
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 6364:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var NodeType, XMLDeclaration, XMLNode, isObject,
      extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
      hasProp = {}.hasOwnProperty;
  
    isObject = __nccwpck_require__(8229).isObject;
  
    XMLNode = __nccwpck_require__(7608);
  
    NodeType = __nccwpck_require__(9267);
  
    module.exports = XMLDeclaration = (function(superClass) {
      extend(XMLDeclaration, superClass);
  
      function XMLDeclaration(parent, version, encoding, standalone) {
        var ref;
        XMLDeclaration.__super__.constructor.call(this, parent);
        if (isObject(version)) {
          ref = version, version = ref.version, encoding = ref.encoding, standalone = ref.standalone;
        }
        if (!version) {
          version = '1.0';
        }
        this.type = NodeType.Declaration;
        this.version = this.stringify.xmlVersion(version);
        if (encoding != null) {
          this.encoding = this.stringify.xmlEncoding(encoding);
        }
        if (standalone != null) {
          this.standalone = this.stringify.xmlStandalone(standalone);
        }
      }
  
      XMLDeclaration.prototype.toString = function(options) {
        return this.options.writer.declaration(this, this.options.writer.filterOptions(options));
      };
  
      return XMLDeclaration;
  
    })(XMLNode);
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 1801:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var NodeType, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDocType, XMLNamedNodeMap, XMLNode, isObject,
      extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
      hasProp = {}.hasOwnProperty;
  
    isObject = __nccwpck_require__(8229).isObject;
  
    XMLNode = __nccwpck_require__(7608);
  
    NodeType = __nccwpck_require__(9267);
  
    XMLDTDAttList = __nccwpck_require__(1015);
  
    XMLDTDEntity = __nccwpck_require__(53);
  
    XMLDTDElement = __nccwpck_require__(2421);
  
    XMLDTDNotation = __nccwpck_require__(2837);
  
    XMLNamedNodeMap = __nccwpck_require__(4361);
  
    module.exports = XMLDocType = (function(superClass) {
      extend(XMLDocType, superClass);
  
      function XMLDocType(parent, pubID, sysID) {
        var child, i, len, ref, ref1, ref2;
        XMLDocType.__super__.constructor.call(this, parent);
        this.type = NodeType.DocType;
        if (parent.children) {
          ref = parent.children;
          for (i = 0, len = ref.length; i < len; i++) {
            child = ref[i];
            if (child.type === NodeType.Element) {
              this.name = child.name;
              break;
            }
          }
        }
        this.documentObject = parent;
        if (isObject(pubID)) {
          ref1 = pubID, pubID = ref1.pubID, sysID = ref1.sysID;
        }
        if (sysID == null) {
          ref2 = [pubID, sysID], sysID = ref2[0], pubID = ref2[1];
        }
        if (pubID != null) {
          this.pubID = this.stringify.dtdPubID(pubID);
        }
        if (sysID != null) {
          this.sysID = this.stringify.dtdSysID(sysID);
        }
      }
  
      Object.defineProperty(XMLDocType.prototype, 'entities', {
        get: function() {
          var child, i, len, nodes, ref;
          nodes = {};
          ref = this.children;
          for (i = 0, len = ref.length; i < len; i++) {
            child = ref[i];
            if ((child.type === NodeType.EntityDeclaration) && !child.pe) {
              nodes[child.name] = child;
            }
          }
          return new XMLNamedNodeMap(nodes);
        }
      });
  
      Object.defineProperty(XMLDocType.prototype, 'notations', {
        get: function() {
          var child, i, len, nodes, ref;
          nodes = {};
          ref = this.children;
          for (i = 0, len = ref.length; i < len; i++) {
            child = ref[i];
            if (child.type === NodeType.NotationDeclaration) {
              nodes[child.name] = child;
            }
          }
          return new XMLNamedNodeMap(nodes);
        }
      });
  
      Object.defineProperty(XMLDocType.prototype, 'publicId', {
        get: function() {
          return this.pubID;
        }
      });
  
      Object.defineProperty(XMLDocType.prototype, 'systemId', {
        get: function() {
          return this.sysID;
        }
      });
  
      Object.defineProperty(XMLDocType.prototype, 'internalSubset', {
        get: function() {
          throw new Error("This DOM method is not implemented." + this.debugInfo());
        }
      });
  
      XMLDocType.prototype.element = function(name, value) {
        var child;
        child = new XMLDTDElement(this, name, value);
        this.children.push(child);
        return this;
      };
  
      XMLDocType.prototype.attList = function(elementName, attributeName, attributeType, defaultValueType, defaultValue) {
        var child;
        child = new XMLDTDAttList(this, elementName, attributeName, attributeType, defaultValueType, defaultValue);
        this.children.push(child);
        return this;
      };
  
      XMLDocType.prototype.entity = function(name, value) {
        var child;
        child = new XMLDTDEntity(this, false, name, value);
        this.children.push(child);
        return this;
      };
  
      XMLDocType.prototype.pEntity = function(name, value) {
        var child;
        child = new XMLDTDEntity(this, true, name, value);
        this.children.push(child);
        return this;
      };
  
      XMLDocType.prototype.notation = function(name, value) {
        var child;
        child = new XMLDTDNotation(this, name, value);
        this.children.push(child);
        return this;
      };
  
      XMLDocType.prototype.toString = function(options) {
        return this.options.writer.docType(this, this.options.writer.filterOptions(options));
      };
  
      XMLDocType.prototype.ele = function(name, value) {
        return this.element(name, value);
      };
  
      XMLDocType.prototype.att = function(elementName, attributeName, attributeType, defaultValueType, defaultValue) {
        return this.attList(elementName, attributeName, attributeType, defaultValueType, defaultValue);
      };
  
      XMLDocType.prototype.ent = function(name, value) {
        return this.entity(name, value);
      };
  
      XMLDocType.prototype.pent = function(name, value) {
        return this.pEntity(name, value);
      };
  
      XMLDocType.prototype.not = function(name, value) {
        return this.notation(name, value);
      };
  
      XMLDocType.prototype.up = function() {
        return this.root() || this.documentObject;
      };
  
      XMLDocType.prototype.isEqualNode = function(node) {
        if (!XMLDocType.__super__.isEqualNode.apply(this, arguments).isEqualNode(node)) {
          return false;
        }
        if (node.name !== this.name) {
          return false;
        }
        if (node.publicId !== this.publicId) {
          return false;
        }
        if (node.systemId !== this.systemId) {
          return false;
        }
        return true;
      };
  
      return XMLDocType;
  
    })(XMLNode);
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 3730:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var NodeType, XMLDOMConfiguration, XMLDOMImplementation, XMLDocument, XMLNode, XMLStringWriter, XMLStringifier, isPlainObject,
      extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
      hasProp = {}.hasOwnProperty;
  
    isPlainObject = __nccwpck_require__(8229).isPlainObject;
  
    XMLDOMImplementation = __nccwpck_require__(8310);
  
    XMLDOMConfiguration = __nccwpck_require__(7465);
  
    XMLNode = __nccwpck_require__(7608);
  
    NodeType = __nccwpck_require__(9267);
  
    XMLStringifier = __nccwpck_require__(8594);
  
    XMLStringWriter = __nccwpck_require__(5913);
  
    module.exports = XMLDocument = (function(superClass) {
      extend(XMLDocument, superClass);
  
      function XMLDocument(options) {
        XMLDocument.__super__.constructor.call(this, null);
        this.name = "#document";
        this.type = NodeType.Document;
        this.documentURI = null;
        this.domConfig = new XMLDOMConfiguration();
        options || (options = {});
        if (!options.writer) {
          options.writer = new XMLStringWriter();
        }
        this.options = options;
        this.stringify = new XMLStringifier(options);
      }
  
      Object.defineProperty(XMLDocument.prototype, 'implementation', {
        value: new XMLDOMImplementation()
      });
  
      Object.defineProperty(XMLDocument.prototype, 'doctype', {
        get: function() {
          var child, i, len, ref;
          ref = this.children;
          for (i = 0, len = ref.length; i < len; i++) {
            child = ref[i];
            if (child.type === NodeType.DocType) {
              return child;
            }
          }
          return null;
        }
      });
  
      Object.defineProperty(XMLDocument.prototype, 'documentElement', {
        get: function() {
          return this.rootObject || null;
        }
      });
  
      Object.defineProperty(XMLDocument.prototype, 'inputEncoding', {
        get: function() {
          return null;
        }
      });
  
      Object.defineProperty(XMLDocument.prototype, 'strictErrorChecking', {
        get: function() {
          return false;
        }
      });
  
      Object.defineProperty(XMLDocument.prototype, 'xmlEncoding', {
        get: function() {
          if (this.children.length !== 0 && this.children[0].type === NodeType.Declaration) {
            return this.children[0].encoding;
          } else {
            return null;
          }
        }
      });
  
      Object.defineProperty(XMLDocument.prototype, 'xmlStandalone', {
        get: function() {
          if (this.children.length !== 0 && this.children[0].type === NodeType.Declaration) {
            return this.children[0].standalone === 'yes';
          } else {
            return false;
          }
        }
      });
  
      Object.defineProperty(XMLDocument.prototype, 'xmlVersion', {
        get: function() {
          if (this.children.length !== 0 && this.children[0].type === NodeType.Declaration) {
            return this.children[0].version;
          } else {
            return "1.0";
          }
        }
      });
  
      Object.defineProperty(XMLDocument.prototype, 'URL', {
        get: function() {
          return this.documentURI;
        }
      });
  
      Object.defineProperty(XMLDocument.prototype, 'origin', {
        get: function() {
          return null;
        }
      });
  
      Object.defineProperty(XMLDocument.prototype, 'compatMode', {
        get: function() {
          return null;
        }
      });
  
      Object.defineProperty(XMLDocument.prototype, 'characterSet', {
        get: function() {
          return null;
        }
      });
  
      Object.defineProperty(XMLDocument.prototype, 'contentType', {
        get: function() {
          return null;
        }
      });
  
      XMLDocument.prototype.end = function(writer) {
        var writerOptions;
        writerOptions = {};
        if (!writer) {
          writer = this.options.writer;
        } else if (isPlainObject(writer)) {
          writerOptions = writer;
          writer = this.options.writer;
        }
        return writer.document(this, writer.filterOptions(writerOptions));
      };
  
      XMLDocument.prototype.toString = function(options) {
        return this.options.writer.document(this, this.options.writer.filterOptions(options));
      };
  
      XMLDocument.prototype.createElement = function(tagName) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLDocument.prototype.createDocumentFragment = function() {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLDocument.prototype.createTextNode = function(data) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLDocument.prototype.createComment = function(data) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLDocument.prototype.createCDATASection = function(data) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLDocument.prototype.createProcessingInstruction = function(target, data) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLDocument.prototype.createAttribute = function(name) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLDocument.prototype.createEntityReference = function(name) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLDocument.prototype.getElementsByTagName = function(tagname) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLDocument.prototype.importNode = function(importedNode, deep) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLDocument.prototype.createElementNS = function(namespaceURI, qualifiedName) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLDocument.prototype.createAttributeNS = function(namespaceURI, qualifiedName) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLDocument.prototype.getElementsByTagNameNS = function(namespaceURI, localName) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLDocument.prototype.getElementById = function(elementId) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLDocument.prototype.adoptNode = function(source) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLDocument.prototype.normalizeDocument = function() {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLDocument.prototype.renameNode = function(node, namespaceURI, qualifiedName) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLDocument.prototype.getElementsByClassName = function(classNames) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLDocument.prototype.createEvent = function(eventInterface) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLDocument.prototype.createRange = function() {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLDocument.prototype.createNodeIterator = function(root, whatToShow, filter) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLDocument.prototype.createTreeWalker = function(root, whatToShow, filter) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      return XMLDocument;
  
    })(XMLNode);
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 7356:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var NodeType, WriterState, XMLAttribute, XMLCData, XMLComment, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDeclaration, XMLDocType, XMLDocument, XMLDocumentCB, XMLElement, XMLProcessingInstruction, XMLRaw, XMLStringWriter, XMLStringifier, XMLText, getValue, isFunction, isObject, isPlainObject, ref,
      hasProp = {}.hasOwnProperty;
  
    ref = __nccwpck_require__(8229), isObject = ref.isObject, isFunction = ref.isFunction, isPlainObject = ref.isPlainObject, getValue = ref.getValue;
  
    NodeType = __nccwpck_require__(9267);
  
    XMLDocument = __nccwpck_require__(3730);
  
    XMLElement = __nccwpck_require__(9437);
  
    XMLCData = __nccwpck_require__(333);
  
    XMLComment = __nccwpck_require__(4407);
  
    XMLRaw = __nccwpck_require__(6329);
  
    XMLText = __nccwpck_require__(1318);
  
    XMLProcessingInstruction = __nccwpck_require__(6939);
  
    XMLDeclaration = __nccwpck_require__(6364);
  
    XMLDocType = __nccwpck_require__(1801);
  
    XMLDTDAttList = __nccwpck_require__(1015);
  
    XMLDTDEntity = __nccwpck_require__(53);
  
    XMLDTDElement = __nccwpck_require__(2421);
  
    XMLDTDNotation = __nccwpck_require__(2837);
  
    XMLAttribute = __nccwpck_require__(8376);
  
    XMLStringifier = __nccwpck_require__(8594);
  
    XMLStringWriter = __nccwpck_require__(5913);
  
    WriterState = __nccwpck_require__(9766);
  
    module.exports = XMLDocumentCB = (function() {
      function XMLDocumentCB(options, onData, onEnd) {
        var writerOptions;
        this.name = "?xml";
        this.type = NodeType.Document;
        options || (options = {});
        writerOptions = {};
        if (!options.writer) {
          options.writer = new XMLStringWriter();
        } else if (isPlainObject(options.writer)) {
          writerOptions = options.writer;
          options.writer = new XMLStringWriter();
        }
        this.options = options;
        this.writer = options.writer;
        this.writerOptions = this.writer.filterOptions(writerOptions);
        this.stringify = new XMLStringifier(options);
        this.onDataCallback = onData || function() {};
        this.onEndCallback = onEnd || function() {};
        this.currentNode = null;
        this.currentLevel = -1;
        this.openTags = {};
        this.documentStarted = false;
        this.documentCompleted = false;
        this.root = null;
      }
  
      XMLDocumentCB.prototype.createChildNode = function(node) {
        var att, attName, attributes, child, i, len, ref1, ref2;
        switch (node.type) {
          case NodeType.CData:
            this.cdata(node.value);
            break;
          case NodeType.Comment:
            this.comment(node.value);
            break;
          case NodeType.Element:
            attributes = {};
            ref1 = node.attribs;
            for (attName in ref1) {
              if (!hasProp.call(ref1, attName)) continue;
              att = ref1[attName];
              attributes[attName] = att.value;
            }
            this.node(node.name, attributes);
            break;
          case NodeType.Dummy:
            this.dummy();
            break;
          case NodeType.Raw:
            this.raw(node.value);
            break;
          case NodeType.Text:
            this.text(node.value);
            break;
          case NodeType.ProcessingInstruction:
            this.instruction(node.target, node.value);
            break;
          default:
            throw new Error("This XML node type is not supported in a JS object: " + node.constructor.name);
        }
        ref2 = node.children;
        for (i = 0, len = ref2.length; i < len; i++) {
          child = ref2[i];
          this.createChildNode(child);
          if (child.type === NodeType.Element) {
            this.up();
          }
        }
        return this;
      };
  
      XMLDocumentCB.prototype.dummy = function() {
        return this;
      };
  
      XMLDocumentCB.prototype.node = function(name, attributes, text) {
        var ref1;
        if (name == null) {
          throw new Error("Missing node name.");
        }
        if (this.root && this.currentLevel === -1) {
          throw new Error("Document can only have one root node. " + this.debugInfo(name));
        }
        this.openCurrent();
        name = getValue(name);
        if (attributes == null) {
          attributes = {};
        }
        attributes = getValue(attributes);
        if (!isObject(attributes)) {
          ref1 = [attributes, text], text = ref1[0], attributes = ref1[1];
        }
        this.currentNode = new XMLElement(this, name, attributes);
        this.currentNode.children = false;
        this.currentLevel++;
        this.openTags[this.currentLevel] = this.currentNode;
        if (text != null) {
          this.text(text);
        }
        return this;
      };
  
      XMLDocumentCB.prototype.element = function(name, attributes, text) {
        var child, i, len, oldValidationFlag, ref1, root;
        if (this.currentNode && this.currentNode.type === NodeType.DocType) {
          this.dtdElement.apply(this, arguments);
        } else {
          if (Array.isArray(name) || isObject(name) || isFunction(name)) {
            oldValidationFlag = this.options.noValidation;
            this.options.noValidation = true;
            root = new XMLDocument(this.options).element('TEMP_ROOT');
            root.element(name);
            this.options.noValidation = oldValidationFlag;
            ref1 = root.children;
            for (i = 0, len = ref1.length; i < len; i++) {
              child = ref1[i];
              this.createChildNode(child);
              if (child.type === NodeType.Element) {
                this.up();
              }
            }
          } else {
            this.node(name, attributes, text);
          }
        }
        return this;
      };
  
      XMLDocumentCB.prototype.attribute = function(name, value) {
        var attName, attValue;
        if (!this.currentNode || this.currentNode.children) {
          throw new Error("att() can only be used immediately after an ele() call in callback mode. " + this.debugInfo(name));
        }
        if (name != null) {
          name = getValue(name);
        }
        if (isObject(name)) {
          for (attName in name) {
            if (!hasProp.call(name, attName)) continue;
            attValue = name[attName];
            this.attribute(attName, attValue);
          }
        } else {
          if (isFunction(value)) {
            value = value.apply();
          }
          if (this.options.keepNullAttributes && (value == null)) {
            this.currentNode.attribs[name] = new XMLAttribute(this, name, "");
          } else if (value != null) {
            this.currentNode.attribs[name] = new XMLAttribute(this, name, value);
          }
        }
        return this;
      };
  
      XMLDocumentCB.prototype.text = function(value) {
        var node;
        this.openCurrent();
        node = new XMLText(this, value);
        this.onData(this.writer.text(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
        return this;
      };
  
      XMLDocumentCB.prototype.cdata = function(value) {
        var node;
        this.openCurrent();
        node = new XMLCData(this, value);
        this.onData(this.writer.cdata(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
        return this;
      };
  
      XMLDocumentCB.prototype.comment = function(value) {
        var node;
        this.openCurrent();
        node = new XMLComment(this, value);
        this.onData(this.writer.comment(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
        return this;
      };
  
      XMLDocumentCB.prototype.raw = function(value) {
        var node;
        this.openCurrent();
        node = new XMLRaw(this, value);
        this.onData(this.writer.raw(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
        return this;
      };
  
      XMLDocumentCB.prototype.instruction = function(target, value) {
        var i, insTarget, insValue, len, node;
        this.openCurrent();
        if (target != null) {
          target = getValue(target);
        }
        if (value != null) {
          value = getValue(value);
        }
        if (Array.isArray(target)) {
          for (i = 0, len = target.length; i < len; i++) {
            insTarget = target[i];
            this.instruction(insTarget);
          }
        } else if (isObject(target)) {
          for (insTarget in target) {
            if (!hasProp.call(target, insTarget)) continue;
            insValue = target[insTarget];
            this.instruction(insTarget, insValue);
          }
        } else {
          if (isFunction(value)) {
            value = value.apply();
          }
          node = new XMLProcessingInstruction(this, target, value);
          this.onData(this.writer.processingInstruction(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
        }
        return this;
      };
  
      XMLDocumentCB.prototype.declaration = function(version, encoding, standalone) {
        var node;
        this.openCurrent();
        if (this.documentStarted) {
          throw new Error("declaration() must be the first node.");
        }
        node = new XMLDeclaration(this, version, encoding, standalone);
        this.onData(this.writer.declaration(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
        return this;
      };
  
      XMLDocumentCB.prototype.doctype = function(root, pubID, sysID) {
        this.openCurrent();
        if (root == null) {
          throw new Error("Missing root node name.");
        }
        if (this.root) {
          throw new Error("dtd() must come before the root node.");
        }
        this.currentNode = new XMLDocType(this, pubID, sysID);
        this.currentNode.rootNodeName = root;
        this.currentNode.children = false;
        this.currentLevel++;
        this.openTags[this.currentLevel] = this.currentNode;
        return this;
      };
  
      XMLDocumentCB.prototype.dtdElement = function(name, value) {
        var node;
        this.openCurrent();
        node = new XMLDTDElement(this, name, value);
        this.onData(this.writer.dtdElement(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
        return this;
      };
  
      XMLDocumentCB.prototype.attList = function(elementName, attributeName, attributeType, defaultValueType, defaultValue) {
        var node;
        this.openCurrent();
        node = new XMLDTDAttList(this, elementName, attributeName, attributeType, defaultValueType, defaultValue);
        this.onData(this.writer.dtdAttList(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
        return this;
      };
  
      XMLDocumentCB.prototype.entity = function(name, value) {
        var node;
        this.openCurrent();
        node = new XMLDTDEntity(this, false, name, value);
        this.onData(this.writer.dtdEntity(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
        return this;
      };
  
      XMLDocumentCB.prototype.pEntity = function(name, value) {
        var node;
        this.openCurrent();
        node = new XMLDTDEntity(this, true, name, value);
        this.onData(this.writer.dtdEntity(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
        return this;
      };
  
      XMLDocumentCB.prototype.notation = function(name, value) {
        var node;
        this.openCurrent();
        node = new XMLDTDNotation(this, name, value);
        this.onData(this.writer.dtdNotation(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
        return this;
      };
  
      XMLDocumentCB.prototype.up = function() {
        if (this.currentLevel < 0) {
          throw new Error("The document node has no parent.");
        }
        if (this.currentNode) {
          if (this.currentNode.children) {
            this.closeNode(this.currentNode);
          } else {
            this.openNode(this.currentNode);
          }
          this.currentNode = null;
        } else {
          this.closeNode(this.openTags[this.currentLevel]);
        }
        delete this.openTags[this.currentLevel];
        this.currentLevel--;
        return this;
      };
  
      XMLDocumentCB.prototype.end = function() {
        while (this.currentLevel >= 0) {
          this.up();
        }
        return this.onEnd();
      };
  
      XMLDocumentCB.prototype.openCurrent = function() {
        if (this.currentNode) {
          this.currentNode.children = true;
          return this.openNode(this.currentNode);
        }
      };
  
      XMLDocumentCB.prototype.openNode = function(node) {
        var att, chunk, name, ref1;
        if (!node.isOpen) {
          if (!this.root && this.currentLevel === 0 && node.type === NodeType.Element) {
            this.root = node;
          }
          chunk = '';
          if (node.type === NodeType.Element) {
            this.writerOptions.state = WriterState.OpenTag;
            chunk = this.writer.indent(node, this.writerOptions, this.currentLevel) + '<' + node.name;
            ref1 = node.attribs;
            for (name in ref1) {
              if (!hasProp.call(ref1, name)) continue;
              att = ref1[name];
              chunk += this.writer.attribute(att, this.writerOptions, this.currentLevel);
            }
            chunk += (node.children ? '>' : '/>') + this.writer.endline(node, this.writerOptions, this.currentLevel);
            this.writerOptions.state = WriterState.InsideTag;
          } else {
            this.writerOptions.state = WriterState.OpenTag;
            chunk = this.writer.indent(node, this.writerOptions, this.currentLevel) + '<!DOCTYPE ' + node.rootNodeName;
            if (node.pubID && node.sysID) {
              chunk += ' PUBLIC "' + node.pubID + '" "' + node.sysID + '"';
            } else if (node.sysID) {
              chunk += ' SYSTEM "' + node.sysID + '"';
            }
            if (node.children) {
              chunk += ' [';
              this.writerOptions.state = WriterState.InsideTag;
            } else {
              this.writerOptions.state = WriterState.CloseTag;
              chunk += '>';
            }
            chunk += this.writer.endline(node, this.writerOptions, this.currentLevel);
          }
          this.onData(chunk, this.currentLevel);
          return node.isOpen = true;
        }
      };
  
      XMLDocumentCB.prototype.closeNode = function(node) {
        var chunk;
        if (!node.isClosed) {
          chunk = '';
          this.writerOptions.state = WriterState.CloseTag;
          if (node.type === NodeType.Element) {
            chunk = this.writer.indent(node, this.writerOptions, this.currentLevel) + '</' + node.name + '>' + this.writer.endline(node, this.writerOptions, this.currentLevel);
          } else {
            chunk = this.writer.indent(node, this.writerOptions, this.currentLevel) + ']>' + this.writer.endline(node, this.writerOptions, this.currentLevel);
          }
          this.writerOptions.state = WriterState.None;
          this.onData(chunk, this.currentLevel);
          return node.isClosed = true;
        }
      };
  
      XMLDocumentCB.prototype.onData = function(chunk, level) {
        this.documentStarted = true;
        return this.onDataCallback(chunk, level + 1);
      };
  
      XMLDocumentCB.prototype.onEnd = function() {
        this.documentCompleted = true;
        return this.onEndCallback();
      };
  
      XMLDocumentCB.prototype.debugInfo = function(name) {
        if (name == null) {
          return "";
        } else {
          return "node: <" + name + ">";
        }
      };
  
      XMLDocumentCB.prototype.ele = function() {
        return this.element.apply(this, arguments);
      };
  
      XMLDocumentCB.prototype.nod = function(name, attributes, text) {
        return this.node(name, attributes, text);
      };
  
      XMLDocumentCB.prototype.txt = function(value) {
        return this.text(value);
      };
  
      XMLDocumentCB.prototype.dat = function(value) {
        return this.cdata(value);
      };
  
      XMLDocumentCB.prototype.com = function(value) {
        return this.comment(value);
      };
  
      XMLDocumentCB.prototype.ins = function(target, value) {
        return this.instruction(target, value);
      };
  
      XMLDocumentCB.prototype.dec = function(version, encoding, standalone) {
        return this.declaration(version, encoding, standalone);
      };
  
      XMLDocumentCB.prototype.dtd = function(root, pubID, sysID) {
        return this.doctype(root, pubID, sysID);
      };
  
      XMLDocumentCB.prototype.e = function(name, attributes, text) {
        return this.element(name, attributes, text);
      };
  
      XMLDocumentCB.prototype.n = function(name, attributes, text) {
        return this.node(name, attributes, text);
      };
  
      XMLDocumentCB.prototype.t = function(value) {
        return this.text(value);
      };
  
      XMLDocumentCB.prototype.d = function(value) {
        return this.cdata(value);
      };
  
      XMLDocumentCB.prototype.c = function(value) {
        return this.comment(value);
      };
  
      XMLDocumentCB.prototype.r = function(value) {
        return this.raw(value);
      };
  
      XMLDocumentCB.prototype.i = function(target, value) {
        return this.instruction(target, value);
      };
  
      XMLDocumentCB.prototype.att = function() {
        if (this.currentNode && this.currentNode.type === NodeType.DocType) {
          return this.attList.apply(this, arguments);
        } else {
          return this.attribute.apply(this, arguments);
        }
      };
  
      XMLDocumentCB.prototype.a = function() {
        if (this.currentNode && this.currentNode.type === NodeType.DocType) {
          return this.attList.apply(this, arguments);
        } else {
          return this.attribute.apply(this, arguments);
        }
      };
  
      XMLDocumentCB.prototype.ent = function(name, value) {
        return this.entity(name, value);
      };
  
      XMLDocumentCB.prototype.pent = function(name, value) {
        return this.pEntity(name, value);
      };
  
      XMLDocumentCB.prototype.not = function(name, value) {
        return this.notation(name, value);
      };
  
      return XMLDocumentCB;
  
    })();
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 3590:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var NodeType, XMLDummy, XMLNode,
      extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
      hasProp = {}.hasOwnProperty;
  
    XMLNode = __nccwpck_require__(7608);
  
    NodeType = __nccwpck_require__(9267);
  
    module.exports = XMLDummy = (function(superClass) {
      extend(XMLDummy, superClass);
  
      function XMLDummy(parent) {
        XMLDummy.__super__.constructor.call(this, parent);
        this.type = NodeType.Dummy;
      }
  
      XMLDummy.prototype.clone = function() {
        return Object.create(this);
      };
  
      XMLDummy.prototype.toString = function(options) {
        return '';
      };
  
      return XMLDummy;
  
    })(XMLNode);
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 9437:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var NodeType, XMLAttribute, XMLElement, XMLNamedNodeMap, XMLNode, getValue, isFunction, isObject, ref,
      extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
      hasProp = {}.hasOwnProperty;
  
    ref = __nccwpck_require__(8229), isObject = ref.isObject, isFunction = ref.isFunction, getValue = ref.getValue;
  
    XMLNode = __nccwpck_require__(7608);
  
    NodeType = __nccwpck_require__(9267);
  
    XMLAttribute = __nccwpck_require__(8376);
  
    XMLNamedNodeMap = __nccwpck_require__(4361);
  
    module.exports = XMLElement = (function(superClass) {
      extend(XMLElement, superClass);
  
      function XMLElement(parent, name, attributes) {
        var child, j, len, ref1;
        XMLElement.__super__.constructor.call(this, parent);
        if (name == null) {
          throw new Error("Missing element name. " + this.debugInfo());
        }
        this.name = this.stringify.name(name);
        this.type = NodeType.Element;
        this.attribs = {};
        this.schemaTypeInfo = null;
        if (attributes != null) {
          this.attribute(attributes);
        }
        if (parent.type === NodeType.Document) {
          this.isRoot = true;
          this.documentObject = parent;
          parent.rootObject = this;
          if (parent.children) {
            ref1 = parent.children;
            for (j = 0, len = ref1.length; j < len; j++) {
              child = ref1[j];
              if (child.type === NodeType.DocType) {
                child.name = this.name;
                break;
              }
            }
          }
        }
      }
  
      Object.defineProperty(XMLElement.prototype, 'tagName', {
        get: function() {
          return this.name;
        }
      });
  
      Object.defineProperty(XMLElement.prototype, 'namespaceURI', {
        get: function() {
          return '';
        }
      });
  
      Object.defineProperty(XMLElement.prototype, 'prefix', {
        get: function() {
          return '';
        }
      });
  
      Object.defineProperty(XMLElement.prototype, 'localName', {
        get: function() {
          return this.name;
        }
      });
  
      Object.defineProperty(XMLElement.prototype, 'id', {
        get: function() {
          throw new Error("This DOM method is not implemented." + this.debugInfo());
        }
      });
  
      Object.defineProperty(XMLElement.prototype, 'className', {
        get: function() {
          throw new Error("This DOM method is not implemented." + this.debugInfo());
        }
      });
  
      Object.defineProperty(XMLElement.prototype, 'classList', {
        get: function() {
          throw new Error("This DOM method is not implemented." + this.debugInfo());
        }
      });
  
      Object.defineProperty(XMLElement.prototype, 'attributes', {
        get: function() {
          if (!this.attributeMap || !this.attributeMap.nodes) {
            this.attributeMap = new XMLNamedNodeMap(this.attribs);
          }
          return this.attributeMap;
        }
      });
  
      XMLElement.prototype.clone = function() {
        var att, attName, clonedSelf, ref1;
        clonedSelf = Object.create(this);
        if (clonedSelf.isRoot) {
          clonedSelf.documentObject = null;
        }
        clonedSelf.attribs = {};
        ref1 = this.attribs;
        for (attName in ref1) {
          if (!hasProp.call(ref1, attName)) continue;
          att = ref1[attName];
          clonedSelf.attribs[attName] = att.clone();
        }
        clonedSelf.children = [];
        this.children.forEach(function(child) {
          var clonedChild;
          clonedChild = child.clone();
          clonedChild.parent = clonedSelf;
          return clonedSelf.children.push(clonedChild);
        });
        return clonedSelf;
      };
  
      XMLElement.prototype.attribute = function(name, value) {
        var attName, attValue;
        if (name != null) {
          name = getValue(name);
        }
        if (isObject(name)) {
          for (attName in name) {
            if (!hasProp.call(name, attName)) continue;
            attValue = name[attName];
            this.attribute(attName, attValue);
          }
        } else {
          if (isFunction(value)) {
            value = value.apply();
          }
          if (this.options.keepNullAttributes && (value == null)) {
            this.attribs[name] = new XMLAttribute(this, name, "");
          } else if (value != null) {
            this.attribs[name] = new XMLAttribute(this, name, value);
          }
        }
        return this;
      };
  
      XMLElement.prototype.removeAttribute = function(name) {
        var attName, j, len;
        if (name == null) {
          throw new Error("Missing attribute name. " + this.debugInfo());
        }
        name = getValue(name);
        if (Array.isArray(name)) {
          for (j = 0, len = name.length; j < len; j++) {
            attName = name[j];
            delete this.attribs[attName];
          }
        } else {
          delete this.attribs[name];
        }
        return this;
      };
  
      XMLElement.prototype.toString = function(options) {
        return this.options.writer.element(this, this.options.writer.filterOptions(options));
      };
  
      XMLElement.prototype.att = function(name, value) {
        return this.attribute(name, value);
      };
  
      XMLElement.prototype.a = function(name, value) {
        return this.attribute(name, value);
      };
  
      XMLElement.prototype.getAttribute = function(name) {
        if (this.attribs.hasOwnProperty(name)) {
          return this.attribs[name].value;
        } else {
          return null;
        }
      };
  
      XMLElement.prototype.setAttribute = function(name, value) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLElement.prototype.getAttributeNode = function(name) {
        if (this.attribs.hasOwnProperty(name)) {
          return this.attribs[name];
        } else {
          return null;
        }
      };
  
      XMLElement.prototype.setAttributeNode = function(newAttr) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLElement.prototype.removeAttributeNode = function(oldAttr) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLElement.prototype.getElementsByTagName = function(name) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLElement.prototype.getAttributeNS = function(namespaceURI, localName) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLElement.prototype.setAttributeNS = function(namespaceURI, qualifiedName, value) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLElement.prototype.removeAttributeNS = function(namespaceURI, localName) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLElement.prototype.getAttributeNodeNS = function(namespaceURI, localName) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLElement.prototype.setAttributeNodeNS = function(newAttr) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLElement.prototype.getElementsByTagNameNS = function(namespaceURI, localName) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLElement.prototype.hasAttribute = function(name) {
        return this.attribs.hasOwnProperty(name);
      };
  
      XMLElement.prototype.hasAttributeNS = function(namespaceURI, localName) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLElement.prototype.setIdAttribute = function(name, isId) {
        if (this.attribs.hasOwnProperty(name)) {
          return this.attribs[name].isId;
        } else {
          return isId;
        }
      };
  
      XMLElement.prototype.setIdAttributeNS = function(namespaceURI, localName, isId) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLElement.prototype.setIdAttributeNode = function(idAttr, isId) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLElement.prototype.getElementsByTagName = function(tagname) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLElement.prototype.getElementsByTagNameNS = function(namespaceURI, localName) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLElement.prototype.getElementsByClassName = function(classNames) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLElement.prototype.isEqualNode = function(node) {
        var i, j, ref1;
        if (!XMLElement.__super__.isEqualNode.apply(this, arguments).isEqualNode(node)) {
          return false;
        }
        if (node.namespaceURI !== this.namespaceURI) {
          return false;
        }
        if (node.prefix !== this.prefix) {
          return false;
        }
        if (node.localName !== this.localName) {
          return false;
        }
        if (node.attribs.length !== this.attribs.length) {
          return false;
        }
        for (i = j = 0, ref1 = this.attribs.length - 1; 0 <= ref1 ? j <= ref1 : j >= ref1; i = 0 <= ref1 ? ++j : --j) {
          if (!this.attribs[i].isEqualNode(node.attribs[i])) {
            return false;
          }
        }
        return true;
      };
  
      return XMLElement;
  
    })(XMLNode);
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 4361:
  /***/ (function(module) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var XMLNamedNodeMap;
  
    module.exports = XMLNamedNodeMap = (function() {
      function XMLNamedNodeMap(nodes) {
        this.nodes = nodes;
      }
  
      Object.defineProperty(XMLNamedNodeMap.prototype, 'length', {
        get: function() {
          return Object.keys(this.nodes).length || 0;
        }
      });
  
      XMLNamedNodeMap.prototype.clone = function() {
        return this.nodes = null;
      };
  
      XMLNamedNodeMap.prototype.getNamedItem = function(name) {
        return this.nodes[name];
      };
  
      XMLNamedNodeMap.prototype.setNamedItem = function(node) {
        var oldNode;
        oldNode = this.nodes[node.nodeName];
        this.nodes[node.nodeName] = node;
        return oldNode || null;
      };
  
      XMLNamedNodeMap.prototype.removeNamedItem = function(name) {
        var oldNode;
        oldNode = this.nodes[name];
        delete this.nodes[name];
        return oldNode || null;
      };
  
      XMLNamedNodeMap.prototype.item = function(index) {
        return this.nodes[Object.keys(this.nodes)[index]] || null;
      };
  
      XMLNamedNodeMap.prototype.getNamedItemNS = function(namespaceURI, localName) {
        throw new Error("This DOM method is not implemented.");
      };
  
      XMLNamedNodeMap.prototype.setNamedItemNS = function(node) {
        throw new Error("This DOM method is not implemented.");
      };
  
      XMLNamedNodeMap.prototype.removeNamedItemNS = function(namespaceURI, localName) {
        throw new Error("This DOM method is not implemented.");
      };
  
      return XMLNamedNodeMap;
  
    })();
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 7608:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var DocumentPosition, NodeType, XMLCData, XMLComment, XMLDeclaration, XMLDocType, XMLDummy, XMLElement, XMLNamedNodeMap, XMLNode, XMLNodeList, XMLProcessingInstruction, XMLRaw, XMLText, getValue, isEmpty, isFunction, isObject, ref1,
      hasProp = {}.hasOwnProperty;
  
    ref1 = __nccwpck_require__(8229), isObject = ref1.isObject, isFunction = ref1.isFunction, isEmpty = ref1.isEmpty, getValue = ref1.getValue;
  
    XMLElement = null;
  
    XMLCData = null;
  
    XMLComment = null;
  
    XMLDeclaration = null;
  
    XMLDocType = null;
  
    XMLRaw = null;
  
    XMLText = null;
  
    XMLProcessingInstruction = null;
  
    XMLDummy = null;
  
    NodeType = null;
  
    XMLNodeList = null;
  
    XMLNamedNodeMap = null;
  
    DocumentPosition = null;
  
    module.exports = XMLNode = (function() {
      function XMLNode(parent1) {
        this.parent = parent1;
        if (this.parent) {
          this.options = this.parent.options;
          this.stringify = this.parent.stringify;
        }
        this.value = null;
        this.children = [];
        this.baseURI = null;
        if (!XMLElement) {
          XMLElement = __nccwpck_require__(9437);
          XMLCData = __nccwpck_require__(333);
          XMLComment = __nccwpck_require__(4407);
          XMLDeclaration = __nccwpck_require__(6364);
          XMLDocType = __nccwpck_require__(1801);
          XMLRaw = __nccwpck_require__(6329);
          XMLText = __nccwpck_require__(1318);
          XMLProcessingInstruction = __nccwpck_require__(6939);
          XMLDummy = __nccwpck_require__(3590);
          NodeType = __nccwpck_require__(9267);
          XMLNodeList = __nccwpck_require__(6768);
          XMLNamedNodeMap = __nccwpck_require__(4361);
          DocumentPosition = __nccwpck_require__(2839);
        }
      }
  
      Object.defineProperty(XMLNode.prototype, 'nodeName', {
        get: function() {
          return this.name;
        }
      });
  
      Object.defineProperty(XMLNode.prototype, 'nodeType', {
        get: function() {
          return this.type;
        }
      });
  
      Object.defineProperty(XMLNode.prototype, 'nodeValue', {
        get: function() {
          return this.value;
        }
      });
  
      Object.defineProperty(XMLNode.prototype, 'parentNode', {
        get: function() {
          return this.parent;
        }
      });
  
      Object.defineProperty(XMLNode.prototype, 'childNodes', {
        get: function() {
          if (!this.childNodeList || !this.childNodeList.nodes) {
            this.childNodeList = new XMLNodeList(this.children);
          }
          return this.childNodeList;
        }
      });
  
      Object.defineProperty(XMLNode.prototype, 'firstChild', {
        get: function() {
          return this.children[0] || null;
        }
      });
  
      Object.defineProperty(XMLNode.prototype, 'lastChild', {
        get: function() {
          return this.children[this.children.length - 1] || null;
        }
      });
  
      Object.defineProperty(XMLNode.prototype, 'previousSibling', {
        get: function() {
          var i;
          i = this.parent.children.indexOf(this);
          return this.parent.children[i - 1] || null;
        }
      });
  
      Object.defineProperty(XMLNode.prototype, 'nextSibling', {
        get: function() {
          var i;
          i = this.parent.children.indexOf(this);
          return this.parent.children[i + 1] || null;
        }
      });
  
      Object.defineProperty(XMLNode.prototype, 'ownerDocument', {
        get: function() {
          return this.document() || null;
        }
      });
  
      Object.defineProperty(XMLNode.prototype, 'textContent', {
        get: function() {
          var child, j, len, ref2, str;
          if (this.nodeType === NodeType.Element || this.nodeType === NodeType.DocumentFragment) {
            str = '';
            ref2 = this.children;
            for (j = 0, len = ref2.length; j < len; j++) {
              child = ref2[j];
              if (child.textContent) {
                str += child.textContent;
              }
            }
            return str;
          } else {
            return null;
          }
        },
        set: function(value) {
          throw new Error("This DOM method is not implemented." + this.debugInfo());
        }
      });
  
      XMLNode.prototype.setParent = function(parent) {
        var child, j, len, ref2, results;
        this.parent = parent;
        if (parent) {
          this.options = parent.options;
          this.stringify = parent.stringify;
        }
        ref2 = this.children;
        results = [];
        for (j = 0, len = ref2.length; j < len; j++) {
          child = ref2[j];
          results.push(child.setParent(this));
        }
        return results;
      };
  
      XMLNode.prototype.element = function(name, attributes, text) {
        var childNode, item, j, k, key, lastChild, len, len1, ref2, ref3, val;
        lastChild = null;
        if (attributes === null && (text == null)) {
          ref2 = [{}, null], attributes = ref2[0], text = ref2[1];
        }
        if (attributes == null) {
          attributes = {};
        }
        attributes = getValue(attributes);
        if (!isObject(attributes)) {
          ref3 = [attributes, text], text = ref3[0], attributes = ref3[1];
        }
        if (name != null) {
          name = getValue(name);
        }
        if (Array.isArray(name)) {
          for (j = 0, len = name.length; j < len; j++) {
            item = name[j];
            lastChild = this.element(item);
          }
        } else if (isFunction(name)) {
          lastChild = this.element(name.apply());
        } else if (isObject(name)) {
          for (key in name) {
            if (!hasProp.call(name, key)) continue;
            val = name[key];
            if (isFunction(val)) {
              val = val.apply();
            }
            if (!this.options.ignoreDecorators && this.stringify.convertAttKey && key.indexOf(this.stringify.convertAttKey) === 0) {
              lastChild = this.attribute(key.substr(this.stringify.convertAttKey.length), val);
            } else if (!this.options.separateArrayItems && Array.isArray(val) && isEmpty(val)) {
              lastChild = this.dummy();
            } else if (isObject(val) && isEmpty(val)) {
              lastChild = this.element(key);
            } else if (!this.options.keepNullNodes && (val == null)) {
              lastChild = this.dummy();
            } else if (!this.options.separateArrayItems && Array.isArray(val)) {
              for (k = 0, len1 = val.length; k < len1; k++) {
                item = val[k];
                childNode = {};
                childNode[key] = item;
                lastChild = this.element(childNode);
              }
            } else if (isObject(val)) {
              if (!this.options.ignoreDecorators && this.stringify.convertTextKey && key.indexOf(this.stringify.convertTextKey) === 0) {
                lastChild = this.element(val);
              } else {
                lastChild = this.element(key);
                lastChild.element(val);
              }
            } else {
              lastChild = this.element(key, val);
            }
          }
        } else if (!this.options.keepNullNodes && text === null) {
          lastChild = this.dummy();
        } else {
          if (!this.options.ignoreDecorators && this.stringify.convertTextKey && name.indexOf(this.stringify.convertTextKey) === 0) {
            lastChild = this.text(text);
          } else if (!this.options.ignoreDecorators && this.stringify.convertCDataKey && name.indexOf(this.stringify.convertCDataKey) === 0) {
            lastChild = this.cdata(text);
          } else if (!this.options.ignoreDecorators && this.stringify.convertCommentKey && name.indexOf(this.stringify.convertCommentKey) === 0) {
            lastChild = this.comment(text);
          } else if (!this.options.ignoreDecorators && this.stringify.convertRawKey && name.indexOf(this.stringify.convertRawKey) === 0) {
            lastChild = this.raw(text);
          } else if (!this.options.ignoreDecorators && this.stringify.convertPIKey && name.indexOf(this.stringify.convertPIKey) === 0) {
            lastChild = this.instruction(name.substr(this.stringify.convertPIKey.length), text);
          } else {
            lastChild = this.node(name, attributes, text);
          }
        }
        if (lastChild == null) {
          throw new Error("Could not create any elements with: " + name + ". " + this.debugInfo());
        }
        return lastChild;
      };
  
      XMLNode.prototype.insertBefore = function(name, attributes, text) {
        var child, i, newChild, refChild, removed;
        if (name != null ? name.type : void 0) {
          newChild = name;
          refChild = attributes;
          newChild.setParent(this);
          if (refChild) {
            i = children.indexOf(refChild);
            removed = children.splice(i);
            children.push(newChild);
            Array.prototype.push.apply(children, removed);
          } else {
            children.push(newChild);
          }
          return newChild;
        } else {
          if (this.isRoot) {
            throw new Error("Cannot insert elements at root level. " + this.debugInfo(name));
          }
          i = this.parent.children.indexOf(this);
          removed = this.parent.children.splice(i);
          child = this.parent.element(name, attributes, text);
          Array.prototype.push.apply(this.parent.children, removed);
          return child;
        }
      };
  
      XMLNode.prototype.insertAfter = function(name, attributes, text) {
        var child, i, removed;
        if (this.isRoot) {
          throw new Error("Cannot insert elements at root level. " + this.debugInfo(name));
        }
        i = this.parent.children.indexOf(this);
        removed = this.parent.children.splice(i + 1);
        child = this.parent.element(name, attributes, text);
        Array.prototype.push.apply(this.parent.children, removed);
        return child;
      };
  
      XMLNode.prototype.remove = function() {
        var i, ref2;
        if (this.isRoot) {
          throw new Error("Cannot remove the root element. " + this.debugInfo());
        }
        i = this.parent.children.indexOf(this);
        [].splice.apply(this.parent.children, [i, i - i + 1].concat(ref2 = [])), ref2;
        return this.parent;
      };
  
      XMLNode.prototype.node = function(name, attributes, text) {
        var child, ref2;
        if (name != null) {
          name = getValue(name);
        }
        attributes || (attributes = {});
        attributes = getValue(attributes);
        if (!isObject(attributes)) {
          ref2 = [attributes, text], text = ref2[0], attributes = ref2[1];
        }
        child = new XMLElement(this, name, attributes);
        if (text != null) {
          child.text(text);
        }
        this.children.push(child);
        return child;
      };
  
      XMLNode.prototype.text = function(value) {
        var child;
        if (isObject(value)) {
          this.element(value);
        }
        child = new XMLText(this, value);
        this.children.push(child);
        return this;
      };
  
      XMLNode.prototype.cdata = function(value) {
        var child;
        child = new XMLCData(this, value);
        this.children.push(child);
        return this;
      };
  
      XMLNode.prototype.comment = function(value) {
        var child;
        child = new XMLComment(this, value);
        this.children.push(child);
        return this;
      };
  
      XMLNode.prototype.commentBefore = function(value) {
        var child, i, removed;
        i = this.parent.children.indexOf(this);
        removed = this.parent.children.splice(i);
        child = this.parent.comment(value);
        Array.prototype.push.apply(this.parent.children, removed);
        return this;
      };
  
      XMLNode.prototype.commentAfter = function(value) {
        var child, i, removed;
        i = this.parent.children.indexOf(this);
        removed = this.parent.children.splice(i + 1);
        child = this.parent.comment(value);
        Array.prototype.push.apply(this.parent.children, removed);
        return this;
      };
  
      XMLNode.prototype.raw = function(value) {
        var child;
        child = new XMLRaw(this, value);
        this.children.push(child);
        return this;
      };
  
      XMLNode.prototype.dummy = function() {
        var child;
        child = new XMLDummy(this);
        return child;
      };
  
      XMLNode.prototype.instruction = function(target, value) {
        var insTarget, insValue, instruction, j, len;
        if (target != null) {
          target = getValue(target);
        }
        if (value != null) {
          value = getValue(value);
        }
        if (Array.isArray(target)) {
          for (j = 0, len = target.length; j < len; j++) {
            insTarget = target[j];
            this.instruction(insTarget);
          }
        } else if (isObject(target)) {
          for (insTarget in target) {
            if (!hasProp.call(target, insTarget)) continue;
            insValue = target[insTarget];
            this.instruction(insTarget, insValue);
          }
        } else {
          if (isFunction(value)) {
            value = value.apply();
          }
          instruction = new XMLProcessingInstruction(this, target, value);
          this.children.push(instruction);
        }
        return this;
      };
  
      XMLNode.prototype.instructionBefore = function(target, value) {
        var child, i, removed;
        i = this.parent.children.indexOf(this);
        removed = this.parent.children.splice(i);
        child = this.parent.instruction(target, value);
        Array.prototype.push.apply(this.parent.children, removed);
        return this;
      };
  
      XMLNode.prototype.instructionAfter = function(target, value) {
        var child, i, removed;
        i = this.parent.children.indexOf(this);
        removed = this.parent.children.splice(i + 1);
        child = this.parent.instruction(target, value);
        Array.prototype.push.apply(this.parent.children, removed);
        return this;
      };
  
      XMLNode.prototype.declaration = function(version, encoding, standalone) {
        var doc, xmldec;
        doc = this.document();
        xmldec = new XMLDeclaration(doc, version, encoding, standalone);
        if (doc.children.length === 0) {
          doc.children.unshift(xmldec);
        } else if (doc.children[0].type === NodeType.Declaration) {
          doc.children[0] = xmldec;
        } else {
          doc.children.unshift(xmldec);
        }
        return doc.root() || doc;
      };
  
      XMLNode.prototype.dtd = function(pubID, sysID) {
        var child, doc, doctype, i, j, k, len, len1, ref2, ref3;
        doc = this.document();
        doctype = new XMLDocType(doc, pubID, sysID);
        ref2 = doc.children;
        for (i = j = 0, len = ref2.length; j < len; i = ++j) {
          child = ref2[i];
          if (child.type === NodeType.DocType) {
            doc.children[i] = doctype;
            return doctype;
          }
        }
        ref3 = doc.children;
        for (i = k = 0, len1 = ref3.length; k < len1; i = ++k) {
          child = ref3[i];
          if (child.isRoot) {
            doc.children.splice(i, 0, doctype);
            return doctype;
          }
        }
        doc.children.push(doctype);
        return doctype;
      };
  
      XMLNode.prototype.up = function() {
        if (this.isRoot) {
          throw new Error("The root node has no parent. Use doc() if you need to get the document object.");
        }
        return this.parent;
      };
  
      XMLNode.prototype.root = function() {
        var node;
        node = this;
        while (node) {
          if (node.type === NodeType.Document) {
            return node.rootObject;
          } else if (node.isRoot) {
            return node;
          } else {
            node = node.parent;
          }
        }
      };
  
      XMLNode.prototype.document = function() {
        var node;
        node = this;
        while (node) {
          if (node.type === NodeType.Document) {
            return node;
          } else {
            node = node.parent;
          }
        }
      };
  
      XMLNode.prototype.end = function(options) {
        return this.document().end(options);
      };
  
      XMLNode.prototype.prev = function() {
        var i;
        i = this.parent.children.indexOf(this);
        if (i < 1) {
          throw new Error("Already at the first node. " + this.debugInfo());
        }
        return this.parent.children[i - 1];
      };
  
      XMLNode.prototype.next = function() {
        var i;
        i = this.parent.children.indexOf(this);
        if (i === -1 || i === this.parent.children.length - 1) {
          throw new Error("Already at the last node. " + this.debugInfo());
        }
        return this.parent.children[i + 1];
      };
  
      XMLNode.prototype.importDocument = function(doc) {
        var clonedRoot;
        clonedRoot = doc.root().clone();
        clonedRoot.parent = this;
        clonedRoot.isRoot = false;
        this.children.push(clonedRoot);
        return this;
      };
  
      XMLNode.prototype.debugInfo = function(name) {
        var ref2, ref3;
        name = name || this.name;
        if ((name == null) && !((ref2 = this.parent) != null ? ref2.name : void 0)) {
          return "";
        } else if (name == null) {
          return "parent: <" + this.parent.name + ">";
        } else if (!((ref3 = this.parent) != null ? ref3.name : void 0)) {
          return "node: <" + name + ">";
        } else {
          return "node: <" + name + ">, parent: <" + this.parent.name + ">";
        }
      };
  
      XMLNode.prototype.ele = function(name, attributes, text) {
        return this.element(name, attributes, text);
      };
  
      XMLNode.prototype.nod = function(name, attributes, text) {
        return this.node(name, attributes, text);
      };
  
      XMLNode.prototype.txt = function(value) {
        return this.text(value);
      };
  
      XMLNode.prototype.dat = function(value) {
        return this.cdata(value);
      };
  
      XMLNode.prototype.com = function(value) {
        return this.comment(value);
      };
  
      XMLNode.prototype.ins = function(target, value) {
        return this.instruction(target, value);
      };
  
      XMLNode.prototype.doc = function() {
        return this.document();
      };
  
      XMLNode.prototype.dec = function(version, encoding, standalone) {
        return this.declaration(version, encoding, standalone);
      };
  
      XMLNode.prototype.e = function(name, attributes, text) {
        return this.element(name, attributes, text);
      };
  
      XMLNode.prototype.n = function(name, attributes, text) {
        return this.node(name, attributes, text);
      };
  
      XMLNode.prototype.t = function(value) {
        return this.text(value);
      };
  
      XMLNode.prototype.d = function(value) {
        return this.cdata(value);
      };
  
      XMLNode.prototype.c = function(value) {
        return this.comment(value);
      };
  
      XMLNode.prototype.r = function(value) {
        return this.raw(value);
      };
  
      XMLNode.prototype.i = function(target, value) {
        return this.instruction(target, value);
      };
  
      XMLNode.prototype.u = function() {
        return this.up();
      };
  
      XMLNode.prototype.importXMLBuilder = function(doc) {
        return this.importDocument(doc);
      };
  
      XMLNode.prototype.replaceChild = function(newChild, oldChild) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLNode.prototype.removeChild = function(oldChild) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLNode.prototype.appendChild = function(newChild) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLNode.prototype.hasChildNodes = function() {
        return this.children.length !== 0;
      };
  
      XMLNode.prototype.cloneNode = function(deep) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLNode.prototype.normalize = function() {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLNode.prototype.isSupported = function(feature, version) {
        return true;
      };
  
      XMLNode.prototype.hasAttributes = function() {
        return this.attribs.length !== 0;
      };
  
      XMLNode.prototype.compareDocumentPosition = function(other) {
        var ref, res;
        ref = this;
        if (ref === other) {
          return 0;
        } else if (this.document() !== other.document()) {
          res = DocumentPosition.Disconnected | DocumentPosition.ImplementationSpecific;
          if (Math.random() < 0.5) {
            res |= DocumentPosition.Preceding;
          } else {
            res |= DocumentPosition.Following;
          }
          return res;
        } else if (ref.isAncestor(other)) {
          return DocumentPosition.Contains | DocumentPosition.Preceding;
        } else if (ref.isDescendant(other)) {
          return DocumentPosition.Contains | DocumentPosition.Following;
        } else if (ref.isPreceding(other)) {
          return DocumentPosition.Preceding;
        } else {
          return DocumentPosition.Following;
        }
      };
  
      XMLNode.prototype.isSameNode = function(other) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLNode.prototype.lookupPrefix = function(namespaceURI) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLNode.prototype.isDefaultNamespace = function(namespaceURI) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLNode.prototype.lookupNamespaceURI = function(prefix) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLNode.prototype.isEqualNode = function(node) {
        var i, j, ref2;
        if (node.nodeType !== this.nodeType) {
          return false;
        }
        if (node.children.length !== this.children.length) {
          return false;
        }
        for (i = j = 0, ref2 = this.children.length - 1; 0 <= ref2 ? j <= ref2 : j >= ref2; i = 0 <= ref2 ? ++j : --j) {
          if (!this.children[i].isEqualNode(node.children[i])) {
            return false;
          }
        }
        return true;
      };
  
      XMLNode.prototype.getFeature = function(feature, version) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLNode.prototype.setUserData = function(key, data, handler) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLNode.prototype.getUserData = function(key) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLNode.prototype.contains = function(other) {
        if (!other) {
          return false;
        }
        return other === this || this.isDescendant(other);
      };
  
      XMLNode.prototype.isDescendant = function(node) {
        var child, isDescendantChild, j, len, ref2;
        ref2 = this.children;
        for (j = 0, len = ref2.length; j < len; j++) {
          child = ref2[j];
          if (node === child) {
            return true;
          }
          isDescendantChild = child.isDescendant(node);
          if (isDescendantChild) {
            return true;
          }
        }
        return false;
      };
  
      XMLNode.prototype.isAncestor = function(node) {
        return node.isDescendant(this);
      };
  
      XMLNode.prototype.isPreceding = function(node) {
        var nodePos, thisPos;
        nodePos = this.treePosition(node);
        thisPos = this.treePosition(this);
        if (nodePos === -1 || thisPos === -1) {
          return false;
        } else {
          return nodePos < thisPos;
        }
      };
  
      XMLNode.prototype.isFollowing = function(node) {
        var nodePos, thisPos;
        nodePos = this.treePosition(node);
        thisPos = this.treePosition(this);
        if (nodePos === -1 || thisPos === -1) {
          return false;
        } else {
          return nodePos > thisPos;
        }
      };
  
      XMLNode.prototype.treePosition = function(node) {
        var found, pos;
        pos = 0;
        found = false;
        this.foreachTreeNode(this.document(), function(childNode) {
          pos++;
          if (!found && childNode === node) {
            return found = true;
          }
        });
        if (found) {
          return pos;
        } else {
          return -1;
        }
      };
  
      XMLNode.prototype.foreachTreeNode = function(node, func) {
        var child, j, len, ref2, res;
        node || (node = this.document());
        ref2 = node.children;
        for (j = 0, len = ref2.length; j < len; j++) {
          child = ref2[j];
          if (res = func(child)) {
            return res;
          } else {
            res = this.foreachTreeNode(child, func);
            if (res) {
              return res;
            }
          }
        }
      };
  
      return XMLNode;
  
    })();
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 6768:
  /***/ (function(module) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var XMLNodeList;
  
    module.exports = XMLNodeList = (function() {
      function XMLNodeList(nodes) {
        this.nodes = nodes;
      }
  
      Object.defineProperty(XMLNodeList.prototype, 'length', {
        get: function() {
          return this.nodes.length || 0;
        }
      });
  
      XMLNodeList.prototype.clone = function() {
        return this.nodes = null;
      };
  
      XMLNodeList.prototype.item = function(index) {
        return this.nodes[index] || null;
      };
  
      return XMLNodeList;
  
    })();
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 6939:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var NodeType, XMLCharacterData, XMLProcessingInstruction,
      extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
      hasProp = {}.hasOwnProperty;
  
    NodeType = __nccwpck_require__(9267);
  
    XMLCharacterData = __nccwpck_require__(7709);
  
    module.exports = XMLProcessingInstruction = (function(superClass) {
      extend(XMLProcessingInstruction, superClass);
  
      function XMLProcessingInstruction(parent, target, value) {
        XMLProcessingInstruction.__super__.constructor.call(this, parent);
        if (target == null) {
          throw new Error("Missing instruction target. " + this.debugInfo());
        }
        this.type = NodeType.ProcessingInstruction;
        this.target = this.stringify.insTarget(target);
        this.name = this.target;
        if (value) {
          this.value = this.stringify.insValue(value);
        }
      }
  
      XMLProcessingInstruction.prototype.clone = function() {
        return Object.create(this);
      };
  
      XMLProcessingInstruction.prototype.toString = function(options) {
        return this.options.writer.processingInstruction(this, this.options.writer.filterOptions(options));
      };
  
      XMLProcessingInstruction.prototype.isEqualNode = function(node) {
        if (!XMLProcessingInstruction.__super__.isEqualNode.apply(this, arguments).isEqualNode(node)) {
          return false;
        }
        if (node.target !== this.target) {
          return false;
        }
        return true;
      };
  
      return XMLProcessingInstruction;
  
    })(XMLCharacterData);
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 6329:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var NodeType, XMLNode, XMLRaw,
      extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
      hasProp = {}.hasOwnProperty;
  
    NodeType = __nccwpck_require__(9267);
  
    XMLNode = __nccwpck_require__(7608);
  
    module.exports = XMLRaw = (function(superClass) {
      extend(XMLRaw, superClass);
  
      function XMLRaw(parent, text) {
        XMLRaw.__super__.constructor.call(this, parent);
        if (text == null) {
          throw new Error("Missing raw text. " + this.debugInfo());
        }
        this.type = NodeType.Raw;
        this.value = this.stringify.raw(text);
      }
  
      XMLRaw.prototype.clone = function() {
        return Object.create(this);
      };
  
      XMLRaw.prototype.toString = function(options) {
        return this.options.writer.raw(this, this.options.writer.filterOptions(options));
      };
  
      return XMLRaw;
  
    })(XMLNode);
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 8601:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var NodeType, WriterState, XMLStreamWriter, XMLWriterBase,
      extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
      hasProp = {}.hasOwnProperty;
  
    NodeType = __nccwpck_require__(9267);
  
    XMLWriterBase = __nccwpck_require__(6752);
  
    WriterState = __nccwpck_require__(9766);
  
    module.exports = XMLStreamWriter = (function(superClass) {
      extend(XMLStreamWriter, superClass);
  
      function XMLStreamWriter(stream, options) {
        this.stream = stream;
        XMLStreamWriter.__super__.constructor.call(this, options);
      }
  
      XMLStreamWriter.prototype.endline = function(node, options, level) {
        if (node.isLastRootNode && options.state === WriterState.CloseTag) {
          return '';
        } else {
          return XMLStreamWriter.__super__.endline.call(this, node, options, level);
        }
      };
  
      XMLStreamWriter.prototype.document = function(doc, options) {
        var child, i, j, k, len, len1, ref, ref1, results;
        ref = doc.children;
        for (i = j = 0, len = ref.length; j < len; i = ++j) {
          child = ref[i];
          child.isLastRootNode = i === doc.children.length - 1;
        }
        options = this.filterOptions(options);
        ref1 = doc.children;
        results = [];
        for (k = 0, len1 = ref1.length; k < len1; k++) {
          child = ref1[k];
          results.push(this.writeChildNode(child, options, 0));
        }
        return results;
      };
  
      XMLStreamWriter.prototype.attribute = function(att, options, level) {
        return this.stream.write(XMLStreamWriter.__super__.attribute.call(this, att, options, level));
      };
  
      XMLStreamWriter.prototype.cdata = function(node, options, level) {
        return this.stream.write(XMLStreamWriter.__super__.cdata.call(this, node, options, level));
      };
  
      XMLStreamWriter.prototype.comment = function(node, options, level) {
        return this.stream.write(XMLStreamWriter.__super__.comment.call(this, node, options, level));
      };
  
      XMLStreamWriter.prototype.declaration = function(node, options, level) {
        return this.stream.write(XMLStreamWriter.__super__.declaration.call(this, node, options, level));
      };
  
      XMLStreamWriter.prototype.docType = function(node, options, level) {
        var child, j, len, ref;
        level || (level = 0);
        this.openNode(node, options, level);
        options.state = WriterState.OpenTag;
        this.stream.write(this.indent(node, options, level));
        this.stream.write('<!DOCTYPE ' + node.root().name);
        if (node.pubID && node.sysID) {
          this.stream.write(' PUBLIC "' + node.pubID + '" "' + node.sysID + '"');
        } else if (node.sysID) {
          this.stream.write(' SYSTEM "' + node.sysID + '"');
        }
        if (node.children.length > 0) {
          this.stream.write(' [');
          this.stream.write(this.endline(node, options, level));
          options.state = WriterState.InsideTag;
          ref = node.children;
          for (j = 0, len = ref.length; j < len; j++) {
            child = ref[j];
            this.writeChildNode(child, options, level + 1);
          }
          options.state = WriterState.CloseTag;
          this.stream.write(']');
        }
        options.state = WriterState.CloseTag;
        this.stream.write(options.spaceBeforeSlash + '>');
        this.stream.write(this.endline(node, options, level));
        options.state = WriterState.None;
        return this.closeNode(node, options, level);
      };
  
      XMLStreamWriter.prototype.element = function(node, options, level) {
        var att, child, childNodeCount, firstChildNode, j, len, name, prettySuppressed, ref, ref1;
        level || (level = 0);
        this.openNode(node, options, level);
        options.state = WriterState.OpenTag;
        this.stream.write(this.indent(node, options, level) + '<' + node.name);
        ref = node.attribs;
        for (name in ref) {
          if (!hasProp.call(ref, name)) continue;
          att = ref[name];
          this.attribute(att, options, level);
        }
        childNodeCount = node.children.length;
        firstChildNode = childNodeCount === 0 ? null : node.children[0];
        if (childNodeCount === 0 || node.children.every(function(e) {
          return (e.type === NodeType.Text || e.type === NodeType.Raw) && e.value === '';
        })) {
          if (options.allowEmpty) {
            this.stream.write('>');
            options.state = WriterState.CloseTag;
            this.stream.write('</' + node.name + '>');
          } else {
            options.state = WriterState.CloseTag;
            this.stream.write(options.spaceBeforeSlash + '/>');
          }
        } else if (options.pretty && childNodeCount === 1 && (firstChildNode.type === NodeType.Text || firstChildNode.type === NodeType.Raw) && (firstChildNode.value != null)) {
          this.stream.write('>');
          options.state = WriterState.InsideTag;
          options.suppressPrettyCount++;
          prettySuppressed = true;
          this.writeChildNode(firstChildNode, options, level + 1);
          options.suppressPrettyCount--;
          prettySuppressed = false;
          options.state = WriterState.CloseTag;
          this.stream.write('</' + node.name + '>');
        } else {
          this.stream.write('>' + this.endline(node, options, level));
          options.state = WriterState.InsideTag;
          ref1 = node.children;
          for (j = 0, len = ref1.length; j < len; j++) {
            child = ref1[j];
            this.writeChildNode(child, options, level + 1);
          }
          options.state = WriterState.CloseTag;
          this.stream.write(this.indent(node, options, level) + '</' + node.name + '>');
        }
        this.stream.write(this.endline(node, options, level));
        options.state = WriterState.None;
        return this.closeNode(node, options, level);
      };
  
      XMLStreamWriter.prototype.processingInstruction = function(node, options, level) {
        return this.stream.write(XMLStreamWriter.__super__.processingInstruction.call(this, node, options, level));
      };
  
      XMLStreamWriter.prototype.raw = function(node, options, level) {
        return this.stream.write(XMLStreamWriter.__super__.raw.call(this, node, options, level));
      };
  
      XMLStreamWriter.prototype.text = function(node, options, level) {
        return this.stream.write(XMLStreamWriter.__super__.text.call(this, node, options, level));
      };
  
      XMLStreamWriter.prototype.dtdAttList = function(node, options, level) {
        return this.stream.write(XMLStreamWriter.__super__.dtdAttList.call(this, node, options, level));
      };
  
      XMLStreamWriter.prototype.dtdElement = function(node, options, level) {
        return this.stream.write(XMLStreamWriter.__super__.dtdElement.call(this, node, options, level));
      };
  
      XMLStreamWriter.prototype.dtdEntity = function(node, options, level) {
        return this.stream.write(XMLStreamWriter.__super__.dtdEntity.call(this, node, options, level));
      };
  
      XMLStreamWriter.prototype.dtdNotation = function(node, options, level) {
        return this.stream.write(XMLStreamWriter.__super__.dtdNotation.call(this, node, options, level));
      };
  
      return XMLStreamWriter;
  
    })(XMLWriterBase);
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 5913:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var XMLStringWriter, XMLWriterBase,
      extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
      hasProp = {}.hasOwnProperty;
  
    XMLWriterBase = __nccwpck_require__(6752);
  
    module.exports = XMLStringWriter = (function(superClass) {
      extend(XMLStringWriter, superClass);
  
      function XMLStringWriter(options) {
        XMLStringWriter.__super__.constructor.call(this, options);
      }
  
      XMLStringWriter.prototype.document = function(doc, options) {
        var child, i, len, r, ref;
        options = this.filterOptions(options);
        r = '';
        ref = doc.children;
        for (i = 0, len = ref.length; i < len; i++) {
          child = ref[i];
          r += this.writeChildNode(child, options, 0);
        }
        if (options.pretty && r.slice(-options.newline.length) === options.newline) {
          r = r.slice(0, -options.newline.length);
        }
        return r;
      };
  
      return XMLStringWriter;
  
    })(XMLWriterBase);
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 8594:
  /***/ (function(module) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var XMLStringifier,
      bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
      hasProp = {}.hasOwnProperty;
  
    module.exports = XMLStringifier = (function() {
      function XMLStringifier(options) {
        this.assertLegalName = bind(this.assertLegalName, this);
        this.assertLegalChar = bind(this.assertLegalChar, this);
        var key, ref, value;
        options || (options = {});
        this.options = options;
        if (!this.options.version) {
          this.options.version = '1.0';
        }
        ref = options.stringify || {};
        for (key in ref) {
          if (!hasProp.call(ref, key)) continue;
          value = ref[key];
          this[key] = value;
        }
      }
  
      XMLStringifier.prototype.name = function(val) {
        if (this.options.noValidation) {
          return val;
        }
        return this.assertLegalName('' + val || '');
      };
  
      XMLStringifier.prototype.text = function(val) {
        if (this.options.noValidation) {
          return val;
        }
        return this.assertLegalChar(this.textEscape('' + val || ''));
      };
  
      XMLStringifier.prototype.cdata = function(val) {
        if (this.options.noValidation) {
          return val;
        }
        val = '' + val || '';
        val = val.replace(']]>', ']]]]><![CDATA[>');
        return this.assertLegalChar(val);
      };
  
      XMLStringifier.prototype.comment = function(val) {
        if (this.options.noValidation) {
          return val;
        }
        val = '' + val || '';
        if (val.match(/--/)) {
          throw new Error("Comment text cannot contain double-hypen: " + val);
        }
        return this.assertLegalChar(val);
      };
  
      XMLStringifier.prototype.raw = function(val) {
        if (this.options.noValidation) {
          return val;
        }
        return '' + val || '';
      };
  
      XMLStringifier.prototype.attValue = function(val) {
        if (this.options.noValidation) {
          return val;
        }
        return this.assertLegalChar(this.attEscape(val = '' + val || ''));
      };
  
      XMLStringifier.prototype.insTarget = function(val) {
        if (this.options.noValidation) {
          return val;
        }
        return this.assertLegalChar('' + val || '');
      };
  
      XMLStringifier.prototype.insValue = function(val) {
        if (this.options.noValidation) {
          return val;
        }
        val = '' + val || '';
        if (val.match(/\?>/)) {
          throw new Error("Invalid processing instruction value: " + val);
        }
        return this.assertLegalChar(val);
      };
  
      XMLStringifier.prototype.xmlVersion = function(val) {
        if (this.options.noValidation) {
          return val;
        }
        val = '' + val || '';
        if (!val.match(/1\.[0-9]+/)) {
          throw new Error("Invalid version number: " + val);
        }
        return val;
      };
  
      XMLStringifier.prototype.xmlEncoding = function(val) {
        if (this.options.noValidation) {
          return val;
        }
        val = '' + val || '';
        if (!val.match(/^[A-Za-z](?:[A-Za-z0-9._-])*$/)) {
          throw new Error("Invalid encoding: " + val);
        }
        return this.assertLegalChar(val);
      };
  
      XMLStringifier.prototype.xmlStandalone = function(val) {
        if (this.options.noValidation) {
          return val;
        }
        if (val) {
          return "yes";
        } else {
          return "no";
        }
      };
  
      XMLStringifier.prototype.dtdPubID = function(val) {
        if (this.options.noValidation) {
          return val;
        }
        return this.assertLegalChar('' + val || '');
      };
  
      XMLStringifier.prototype.dtdSysID = function(val) {
        if (this.options.noValidation) {
          return val;
        }
        return this.assertLegalChar('' + val || '');
      };
  
      XMLStringifier.prototype.dtdElementValue = function(val) {
        if (this.options.noValidation) {
          return val;
        }
        return this.assertLegalChar('' + val || '');
      };
  
      XMLStringifier.prototype.dtdAttType = function(val) {
        if (this.options.noValidation) {
          return val;
        }
        return this.assertLegalChar('' + val || '');
      };
  
      XMLStringifier.prototype.dtdAttDefault = function(val) {
        if (this.options.noValidation) {
          return val;
        }
        return this.assertLegalChar('' + val || '');
      };
  
      XMLStringifier.prototype.dtdEntityValue = function(val) {
        if (this.options.noValidation) {
          return val;
        }
        return this.assertLegalChar('' + val || '');
      };
  
      XMLStringifier.prototype.dtdNData = function(val) {
        if (this.options.noValidation) {
          return val;
        }
        return this.assertLegalChar('' + val || '');
      };
  
      XMLStringifier.prototype.convertAttKey = '@';
  
      XMLStringifier.prototype.convertPIKey = '?';
  
      XMLStringifier.prototype.convertTextKey = '#text';
  
      XMLStringifier.prototype.convertCDataKey = '#cdata';
  
      XMLStringifier.prototype.convertCommentKey = '#comment';
  
      XMLStringifier.prototype.convertRawKey = '#raw';
  
      XMLStringifier.prototype.assertLegalChar = function(str) {
        var regex, res;
        if (this.options.noValidation) {
          return str;
        }
        regex = '';
        if (this.options.version === '1.0') {
          regex = /[\0-\x08\x0B\f\x0E-\x1F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
          if (res = str.match(regex)) {
            throw new Error("Invalid character in string: " + str + " at index " + res.index);
          }
        } else if (this.options.version === '1.1') {
          regex = /[\0\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
          if (res = str.match(regex)) {
            throw new Error("Invalid character in string: " + str + " at index " + res.index);
          }
        }
        return str;
      };
  
      XMLStringifier.prototype.assertLegalName = function(str) {
        var regex;
        if (this.options.noValidation) {
          return str;
        }
        this.assertLegalChar(str);
        regex = /^([:A-Z_a-z\xC0-\xD6\xD8-\xF6\xF8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uDB7F][\uDC00-\uDFFF])([\x2D\.0-:A-Z_a-z\xB7\xC0-\xD6\xD8-\xF6\xF8-\u037D\u037F-\u1FFF\u200C\u200D\u203F\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uDB7F][\uDC00-\uDFFF])*$/;
        if (!str.match(regex)) {
          throw new Error("Invalid character in name");
        }
        return str;
      };
  
      XMLStringifier.prototype.textEscape = function(str) {
        var ampregex;
        if (this.options.noValidation) {
          return str;
        }
        ampregex = this.options.noDoubleEncoding ? /(?!&\S+;)&/g : /&/g;
        return str.replace(ampregex, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/\r/g, '&#xD;');
      };
  
      XMLStringifier.prototype.attEscape = function(str) {
        var ampregex;
        if (this.options.noValidation) {
          return str;
        }
        ampregex = this.options.noDoubleEncoding ? /(?!&\S+;)&/g : /&/g;
        return str.replace(ampregex, '&amp;').replace(/</g, '&lt;').replace(/"/g, '&quot;').replace(/\t/g, '&#x9;').replace(/\n/g, '&#xA;').replace(/\r/g, '&#xD;');
      };
  
      return XMLStringifier;
  
    })();
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 1318:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var NodeType, XMLCharacterData, XMLText,
      extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
      hasProp = {}.hasOwnProperty;
  
    NodeType = __nccwpck_require__(9267);
  
    XMLCharacterData = __nccwpck_require__(7709);
  
    module.exports = XMLText = (function(superClass) {
      extend(XMLText, superClass);
  
      function XMLText(parent, text) {
        XMLText.__super__.constructor.call(this, parent);
        if (text == null) {
          throw new Error("Missing element text. " + this.debugInfo());
        }
        this.name = "#text";
        this.type = NodeType.Text;
        this.value = this.stringify.text(text);
      }
  
      Object.defineProperty(XMLText.prototype, 'isElementContentWhitespace', {
        get: function() {
          throw new Error("This DOM method is not implemented." + this.debugInfo());
        }
      });
  
      Object.defineProperty(XMLText.prototype, 'wholeText', {
        get: function() {
          var next, prev, str;
          str = '';
          prev = this.previousSibling;
          while (prev) {
            str = prev.data + str;
            prev = prev.previousSibling;
          }
          str += this.data;
          next = this.nextSibling;
          while (next) {
            str = str + next.data;
            next = next.nextSibling;
          }
          return str;
        }
      });
  
      XMLText.prototype.clone = function() {
        return Object.create(this);
      };
  
      XMLText.prototype.toString = function(options) {
        return this.options.writer.text(this, this.options.writer.filterOptions(options));
      };
  
      XMLText.prototype.splitText = function(offset) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      XMLText.prototype.replaceWholeText = function(content) {
        throw new Error("This DOM method is not implemented." + this.debugInfo());
      };
  
      return XMLText;
  
    })(XMLCharacterData);
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 6752:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var NodeType, WriterState, XMLCData, XMLComment, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDeclaration, XMLDocType, XMLDummy, XMLElement, XMLProcessingInstruction, XMLRaw, XMLText, XMLWriterBase, assign,
      hasProp = {}.hasOwnProperty;
  
    assign = __nccwpck_require__(8229).assign;
  
    NodeType = __nccwpck_require__(9267);
  
    XMLDeclaration = __nccwpck_require__(6364);
  
    XMLDocType = __nccwpck_require__(1801);
  
    XMLCData = __nccwpck_require__(333);
  
    XMLComment = __nccwpck_require__(4407);
  
    XMLElement = __nccwpck_require__(9437);
  
    XMLRaw = __nccwpck_require__(6329);
  
    XMLText = __nccwpck_require__(1318);
  
    XMLProcessingInstruction = __nccwpck_require__(6939);
  
    XMLDummy = __nccwpck_require__(3590);
  
    XMLDTDAttList = __nccwpck_require__(1015);
  
    XMLDTDElement = __nccwpck_require__(2421);
  
    XMLDTDEntity = __nccwpck_require__(53);
  
    XMLDTDNotation = __nccwpck_require__(2837);
  
    WriterState = __nccwpck_require__(9766);
  
    module.exports = XMLWriterBase = (function() {
      function XMLWriterBase(options) {
        var key, ref, value;
        options || (options = {});
        this.options = options;
        ref = options.writer || {};
        for (key in ref) {
          if (!hasProp.call(ref, key)) continue;
          value = ref[key];
          this["_" + key] = this[key];
          this[key] = value;
        }
      }
  
      XMLWriterBase.prototype.filterOptions = function(options) {
        var filteredOptions, ref, ref1, ref2, ref3, ref4, ref5, ref6;
        options || (options = {});
        options = assign({}, this.options, options);
        filteredOptions = {
          writer: this
        };
        filteredOptions.pretty = options.pretty || false;
        filteredOptions.allowEmpty = options.allowEmpty || false;
        filteredOptions.indent = (ref = options.indent) != null ? ref : '  ';
        filteredOptions.newline = (ref1 = options.newline) != null ? ref1 : '\n';
        filteredOptions.offset = (ref2 = options.offset) != null ? ref2 : 0;
        filteredOptions.dontPrettyTextNodes = (ref3 = (ref4 = options.dontPrettyTextNodes) != null ? ref4 : options.dontprettytextnodes) != null ? ref3 : 0;
        filteredOptions.spaceBeforeSlash = (ref5 = (ref6 = options.spaceBeforeSlash) != null ? ref6 : options.spacebeforeslash) != null ? ref5 : '';
        if (filteredOptions.spaceBeforeSlash === true) {
          filteredOptions.spaceBeforeSlash = ' ';
        }
        filteredOptions.suppressPrettyCount = 0;
        filteredOptions.user = {};
        filteredOptions.state = WriterState.None;
        return filteredOptions;
      };
  
      XMLWriterBase.prototype.indent = function(node, options, level) {
        var indentLevel;
        if (!options.pretty || options.suppressPrettyCount) {
          return '';
        } else if (options.pretty) {
          indentLevel = (level || 0) + options.offset + 1;
          if (indentLevel > 0) {
            return new Array(indentLevel).join(options.indent);
          }
        }
        return '';
      };
  
      XMLWriterBase.prototype.endline = function(node, options, level) {
        if (!options.pretty || options.suppressPrettyCount) {
          return '';
        } else {
          return options.newline;
        }
      };
  
      XMLWriterBase.prototype.attribute = function(att, options, level) {
        var r;
        this.openAttribute(att, options, level);
        r = ' ' + att.name + '="' + att.value + '"';
        this.closeAttribute(att, options, level);
        return r;
      };
  
      XMLWriterBase.prototype.cdata = function(node, options, level) {
        var r;
        this.openNode(node, options, level);
        options.state = WriterState.OpenTag;
        r = this.indent(node, options, level) + '<![CDATA[';
        options.state = WriterState.InsideTag;
        r += node.value;
        options.state = WriterState.CloseTag;
        r += ']]>' + this.endline(node, options, level);
        options.state = WriterState.None;
        this.closeNode(node, options, level);
        return r;
      };
  
      XMLWriterBase.prototype.comment = function(node, options, level) {
        var r;
        this.openNode(node, options, level);
        options.state = WriterState.OpenTag;
        r = this.indent(node, options, level) + '<!-- ';
        options.state = WriterState.InsideTag;
        r += node.value;
        options.state = WriterState.CloseTag;
        r += ' -->' + this.endline(node, options, level);
        options.state = WriterState.None;
        this.closeNode(node, options, level);
        return r;
      };
  
      XMLWriterBase.prototype.declaration = function(node, options, level) {
        var r;
        this.openNode(node, options, level);
        options.state = WriterState.OpenTag;
        r = this.indent(node, options, level) + '<?xml';
        options.state = WriterState.InsideTag;
        r += ' version="' + node.version + '"';
        if (node.encoding != null) {
          r += ' encoding="' + node.encoding + '"';
        }
        if (node.standalone != null) {
          r += ' standalone="' + node.standalone + '"';
        }
        options.state = WriterState.CloseTag;
        r += options.spaceBeforeSlash + '?>';
        r += this.endline(node, options, level);
        options.state = WriterState.None;
        this.closeNode(node, options, level);
        return r;
      };
  
      XMLWriterBase.prototype.docType = function(node, options, level) {
        var child, i, len, r, ref;
        level || (level = 0);
        this.openNode(node, options, level);
        options.state = WriterState.OpenTag;
        r = this.indent(node, options, level);
        r += '<!DOCTYPE ' + node.root().name;
        if (node.pubID && node.sysID) {
          r += ' PUBLIC "' + node.pubID + '" "' + node.sysID + '"';
        } else if (node.sysID) {
          r += ' SYSTEM "' + node.sysID + '"';
        }
        if (node.children.length > 0) {
          r += ' [';
          r += this.endline(node, options, level);
          options.state = WriterState.InsideTag;
          ref = node.children;
          for (i = 0, len = ref.length; i < len; i++) {
            child = ref[i];
            r += this.writeChildNode(child, options, level + 1);
          }
          options.state = WriterState.CloseTag;
          r += ']';
        }
        options.state = WriterState.CloseTag;
        r += options.spaceBeforeSlash + '>';
        r += this.endline(node, options, level);
        options.state = WriterState.None;
        this.closeNode(node, options, level);
        return r;
      };
  
      XMLWriterBase.prototype.element = function(node, options, level) {
        var att, child, childNodeCount, firstChildNode, i, j, len, len1, name, prettySuppressed, r, ref, ref1, ref2;
        level || (level = 0);
        prettySuppressed = false;
        r = '';
        this.openNode(node, options, level);
        options.state = WriterState.OpenTag;
        r += this.indent(node, options, level) + '<' + node.name;
        ref = node.attribs;
        for (name in ref) {
          if (!hasProp.call(ref, name)) continue;
          att = ref[name];
          r += this.attribute(att, options, level);
        }
        childNodeCount = node.children.length;
        firstChildNode = childNodeCount === 0 ? null : node.children[0];
        if (childNodeCount === 0 || node.children.every(function(e) {
          return (e.type === NodeType.Text || e.type === NodeType.Raw) && e.value === '';
        })) {
          if (options.allowEmpty) {
            r += '>';
            options.state = WriterState.CloseTag;
            r += '</' + node.name + '>' + this.endline(node, options, level);
          } else {
            options.state = WriterState.CloseTag;
            r += options.spaceBeforeSlash + '/>' + this.endline(node, options, level);
          }
        } else if (options.pretty && childNodeCount === 1 && (firstChildNode.type === NodeType.Text || firstChildNode.type === NodeType.Raw) && (firstChildNode.value != null)) {
          r += '>';
          options.state = WriterState.InsideTag;
          options.suppressPrettyCount++;
          prettySuppressed = true;
          r += this.writeChildNode(firstChildNode, options, level + 1);
          options.suppressPrettyCount--;
          prettySuppressed = false;
          options.state = WriterState.CloseTag;
          r += '</' + node.name + '>' + this.endline(node, options, level);
        } else {
          if (options.dontPrettyTextNodes) {
            ref1 = node.children;
            for (i = 0, len = ref1.length; i < len; i++) {
              child = ref1[i];
              if ((child.type === NodeType.Text || child.type === NodeType.Raw) && (child.value != null)) {
                options.suppressPrettyCount++;
                prettySuppressed = true;
                break;
              }
            }
          }
          r += '>' + this.endline(node, options, level);
          options.state = WriterState.InsideTag;
          ref2 = node.children;
          for (j = 0, len1 = ref2.length; j < len1; j++) {
            child = ref2[j];
            r += this.writeChildNode(child, options, level + 1);
          }
          options.state = WriterState.CloseTag;
          r += this.indent(node, options, level) + '</' + node.name + '>';
          if (prettySuppressed) {
            options.suppressPrettyCount--;
          }
          r += this.endline(node, options, level);
          options.state = WriterState.None;
        }
        this.closeNode(node, options, level);
        return r;
      };
  
      XMLWriterBase.prototype.writeChildNode = function(node, options, level) {
        switch (node.type) {
          case NodeType.CData:
            return this.cdata(node, options, level);
          case NodeType.Comment:
            return this.comment(node, options, level);
          case NodeType.Element:
            return this.element(node, options, level);
          case NodeType.Raw:
            return this.raw(node, options, level);
          case NodeType.Text:
            return this.text(node, options, level);
          case NodeType.ProcessingInstruction:
            return this.processingInstruction(node, options, level);
          case NodeType.Dummy:
            return '';
          case NodeType.Declaration:
            return this.declaration(node, options, level);
          case NodeType.DocType:
            return this.docType(node, options, level);
          case NodeType.AttributeDeclaration:
            return this.dtdAttList(node, options, level);
          case NodeType.ElementDeclaration:
            return this.dtdElement(node, options, level);
          case NodeType.EntityDeclaration:
            return this.dtdEntity(node, options, level);
          case NodeType.NotationDeclaration:
            return this.dtdNotation(node, options, level);
          default:
            throw new Error("Unknown XML node type: " + node.constructor.name);
        }
      };
  
      XMLWriterBase.prototype.processingInstruction = function(node, options, level) {
        var r;
        this.openNode(node, options, level);
        options.state = WriterState.OpenTag;
        r = this.indent(node, options, level) + '<?';
        options.state = WriterState.InsideTag;
        r += node.target;
        if (node.value) {
          r += ' ' + node.value;
        }
        options.state = WriterState.CloseTag;
        r += options.spaceBeforeSlash + '?>';
        r += this.endline(node, options, level);
        options.state = WriterState.None;
        this.closeNode(node, options, level);
        return r;
      };
  
      XMLWriterBase.prototype.raw = function(node, options, level) {
        var r;
        this.openNode(node, options, level);
        options.state = WriterState.OpenTag;
        r = this.indent(node, options, level);
        options.state = WriterState.InsideTag;
        r += node.value;
        options.state = WriterState.CloseTag;
        r += this.endline(node, options, level);
        options.state = WriterState.None;
        this.closeNode(node, options, level);
        return r;
      };
  
      XMLWriterBase.prototype.text = function(node, options, level) {
        var r;
        this.openNode(node, options, level);
        options.state = WriterState.OpenTag;
        r = this.indent(node, options, level);
        options.state = WriterState.InsideTag;
        r += node.value;
        options.state = WriterState.CloseTag;
        r += this.endline(node, options, level);
        options.state = WriterState.None;
        this.closeNode(node, options, level);
        return r;
      };
  
      XMLWriterBase.prototype.dtdAttList = function(node, options, level) {
        var r;
        this.openNode(node, options, level);
        options.state = WriterState.OpenTag;
        r = this.indent(node, options, level) + '<!ATTLIST';
        options.state = WriterState.InsideTag;
        r += ' ' + node.elementName + ' ' + node.attributeName + ' ' + node.attributeType;
        if (node.defaultValueType !== '#DEFAULT') {
          r += ' ' + node.defaultValueType;
        }
        if (node.defaultValue) {
          r += ' "' + node.defaultValue + '"';
        }
        options.state = WriterState.CloseTag;
        r += options.spaceBeforeSlash + '>' + this.endline(node, options, level);
        options.state = WriterState.None;
        this.closeNode(node, options, level);
        return r;
      };
  
      XMLWriterBase.prototype.dtdElement = function(node, options, level) {
        var r;
        this.openNode(node, options, level);
        options.state = WriterState.OpenTag;
        r = this.indent(node, options, level) + '<!ELEMENT';
        options.state = WriterState.InsideTag;
        r += ' ' + node.name + ' ' + node.value;
        options.state = WriterState.CloseTag;
        r += options.spaceBeforeSlash + '>' + this.endline(node, options, level);
        options.state = WriterState.None;
        this.closeNode(node, options, level);
        return r;
      };
  
      XMLWriterBase.prototype.dtdEntity = function(node, options, level) {
        var r;
        this.openNode(node, options, level);
        options.state = WriterState.OpenTag;
        r = this.indent(node, options, level) + '<!ENTITY';
        options.state = WriterState.InsideTag;
        if (node.pe) {
          r += ' %';
        }
        r += ' ' + node.name;
        if (node.value) {
          r += ' "' + node.value + '"';
        } else {
          if (node.pubID && node.sysID) {
            r += ' PUBLIC "' + node.pubID + '" "' + node.sysID + '"';
          } else if (node.sysID) {
            r += ' SYSTEM "' + node.sysID + '"';
          }
          if (node.nData) {
            r += ' NDATA ' + node.nData;
          }
        }
        options.state = WriterState.CloseTag;
        r += options.spaceBeforeSlash + '>' + this.endline(node, options, level);
        options.state = WriterState.None;
        this.closeNode(node, options, level);
        return r;
      };
  
      XMLWriterBase.prototype.dtdNotation = function(node, options, level) {
        var r;
        this.openNode(node, options, level);
        options.state = WriterState.OpenTag;
        r = this.indent(node, options, level) + '<!NOTATION';
        options.state = WriterState.InsideTag;
        r += ' ' + node.name;
        if (node.pubID && node.sysID) {
          r += ' PUBLIC "' + node.pubID + '" "' + node.sysID + '"';
        } else if (node.pubID) {
          r += ' PUBLIC "' + node.pubID + '"';
        } else if (node.sysID) {
          r += ' SYSTEM "' + node.sysID + '"';
        }
        options.state = WriterState.CloseTag;
        r += options.spaceBeforeSlash + '>' + this.endline(node, options, level);
        options.state = WriterState.None;
        this.closeNode(node, options, level);
        return r;
      };
  
      XMLWriterBase.prototype.openNode = function(node, options, level) {};
  
      XMLWriterBase.prototype.closeNode = function(node, options, level) {};
  
      XMLWriterBase.prototype.openAttribute = function(att, options, level) {};
  
      XMLWriterBase.prototype.closeAttribute = function(att, options, level) {};
  
      return XMLWriterBase;
  
    })();
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 2958:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var NodeType, WriterState, XMLDOMImplementation, XMLDocument, XMLDocumentCB, XMLStreamWriter, XMLStringWriter, assign, isFunction, ref;
  
    ref = __nccwpck_require__(8229), assign = ref.assign, isFunction = ref.isFunction;
  
    XMLDOMImplementation = __nccwpck_require__(8310);
  
    XMLDocument = __nccwpck_require__(3730);
  
    XMLDocumentCB = __nccwpck_require__(7356);
  
    XMLStringWriter = __nccwpck_require__(5913);
  
    XMLStreamWriter = __nccwpck_require__(8601);
  
    NodeType = __nccwpck_require__(9267);
  
    WriterState = __nccwpck_require__(9766);
  
    module.exports.create = function(name, xmldec, doctype, options) {
      var doc, root;
      if (name == null) {
        throw new Error("Root element needs a name.");
      }
      options = assign({}, xmldec, doctype, options);
      doc = new XMLDocument(options);
      root = doc.element(name);
      if (!options.headless) {
        doc.declaration(options);
        if ((options.pubID != null) || (options.sysID != null)) {
          doc.dtd(options);
        }
      }
      return root;
    };
  
    module.exports.begin = function(options, onData, onEnd) {
      var ref1;
      if (isFunction(options)) {
        ref1 = [options, onData], onData = ref1[0], onEnd = ref1[1];
        options = {};
      }
      if (onData) {
        return new XMLDocumentCB(options, onData, onEnd);
      } else {
        return new XMLDocument(options);
      }
    };
  
    module.exports.stringWriter = function(options) {
      return new XMLStringWriter(options);
    };
  
    module.exports.streamWriter = function(stream, options) {
      return new XMLStreamWriter(stream, options);
    };
  
    module.exports.implementation = new XMLDOMImplementation();
  
    module.exports.nodeType = NodeType;
  
    module.exports.writerState = WriterState;
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 2877:
  /***/ ((module) => {
  
  module.exports = eval("require")("encoding");
  
  
  /***/ }),
  
  /***/ 2357:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("assert");;
  
  /***/ }),
  
  /***/ 3129:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("child_process");;
  
  /***/ }),
  
  /***/ 8614:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("events");;
  
  /***/ }),
  
  /***/ 5747:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("fs");;
  
  /***/ }),
  
  /***/ 8605:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("http");;
  
  /***/ }),
  
  /***/ 7211:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("https");;
  
  /***/ }),
  
  /***/ 2087:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("os");;
  
  /***/ }),
  
  /***/ 5622:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("path");;
  
  /***/ }),
  
  /***/ 2413:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("stream");;
  
  /***/ }),
  
  /***/ 4304:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("string_decoder");;
  
  /***/ }),
  
  /***/ 8213:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("timers");;
  
  /***/ }),
  
  /***/ 8835:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("url");;
  
  /***/ }),
  
  /***/ 1669:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("util");;
  
  /***/ }),
  
  /***/ 8761:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("zlib");;
  
  /***/ })
  
  /******/ 	});
  /************************************************************************/
  /******/ 	// The module cache
  /******/ 	var __webpack_module_cache__ = {};
  /******/ 	
  /******/ 	// The require function
  /******/ 	function __nccwpck_require__(moduleId) {
  /******/ 		// Check if module is in cache
  /******/ 		if(__webpack_module_cache__[moduleId]) {
  /******/ 			return __webpack_module_cache__[moduleId].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/compat */
  /******/ 	
  /******/ 	__nccwpck_require__.ab = __dirname + "/";/************************************************************************/
  /******/ 	// module exports must be returned from runtime so entry inlining is disabled
  /******/ 	// startup
  /******/ 	// Load entry module and return exports
  /******/ 	return __nccwpck_require__(2932);
  /******/ })()
  ;